Umer Saeed 
Sr. RF Planning and Optimization Engineer
BSc Telecommunications Engineering, MS Data Science
F2017313014@umt.edu.pk
https://www.linkedin.com/in/engumersaeed/
https://github.com/umersaeed81h
14-Aug-2019
Python for Data Science
Table of contents¶
Chapter 11: Data Frame in Python
- 11.1 What is Data Science?
- 11.2 Data Frames
- 11.3 Library Highlights
- 11.4 Pandas Documentation
- 11.5 Import Python Library
- 11.6 Pandas Version
- 11.7 Create Data Frame
- 11.8 Import Data Frame in Pandas
- 11.9 Export Data Frame From Pandas
- 11.10 Convert the DataFrame to a dictionary
- 11.11 Convert the DataFrame to a array
- 11.12 General Operations on Pandas Data Frames
- 11.13 Data Type
- 11.14 Summary of the Missing Values
- 11.15 Statistical Summary of the Data Frame
- 11.16 Pandas and Pandas Profiling to analyze data
- 11.17 Slicing Subsets of Rows and Columns in Pandas
- 11.18 Conditional Filtering in Pandas
- 11.19 Arithmetic Operations
- 11.20 logical operations
- 11.21 Miscellaneous Operations
- 11.22 8 ways to apply LEFT RIGHT MID in Pandas
- 11.23 Missing data handling
- 11.24 Replace values methods
- 11.25 Varibale types handling
- 11.26 CONCATENATE
- 11.27 Merge Dataframes
- 11.28 Pivot
- 11.29 Pivot Table
- 11.30 Grouper
- 11.31 Melt
- 11.32 Crosstab
- 11.33 groupby
- 11.34 get_group
- 11.35 Transform Function in Pandas
- 11.36 Remove duplicate rows in pandas
- 11.37 Pandas Stack
- 11.38 Pandas Unstack
- 11.39 Python Pandas replicate rows in dataframe
- 11.40 Data manipulations
- 11.41 Data Frame Formatting in Pandas
- 11.42 Time Series Analysis
Chapter 11: Data Frame in Python¶
11.1 What is Data Science?¶
- Data Science or Data Analytics is a process of analyzing large set of data points to get answer on questions related to that data set.
- Pandas is a python module that makes data science easy and effective
11.2 Data Frames¶
Dataframe is a main object in Pandas. It is used to represent data with rows and columnns (tabular or excel spreadsheed like data).
A data frame is a table or a two-dimensional array-like structure in which each column contains values of one variable and each row contains one set of values from each column.
Following are the characteristics of a data frame:
- There can be multiple rows and columns in the data.
- Each row represents a sample of data,
- Each column contains a different variable that describes the samples (rows).
- The data in every column is usually the same type of data – e.g. numbers, strings, dates.
- Unlike matrices, data frames can store different classes of objects in each column;matrices must have every element be the same class.
11.3 Library Highlights¶
A fast and efficient DataFrame object for data manipulation with integrated indexing.
Tools for reading and writing data between in-memory data structures and different formats:
- CSV and text files.
- Microsoft Excel.
- SQL databases.
- The fast HDF5 format.
- etc.
- Intelligent data alignment and integrated handling of missing data: gain automatic label-based alignment in computations and easily manipulate messy data into an orderly form.
- Flexible reshaping and pivoting of data sets.
- Intelligent label-based slicing, fancy indexing, and subsetting of large data sets.
- Columns can be inserted and deleted from data structures for size mutability.
- Aggregating or transforming data with a powerful group by engine allowing split-apply-combine operations on data sets.
- High performance merging and joining of data sets.
- Hierarchical axis indexing provides an intuitive way of working with high-dimensional data in a lower-dimensional data structure.
- Time series-functionality: date range generation and frequency conversion, moving window statistics, moving window linear regressions, date shifting and lagging. Even create domain-specific time offsets and join time series without losing data
- Highly optimized for performance, with critical code paths written in Cython or C.
- Python with pandas is in use in a wide variety of academic and commercial domains, including Finance, Neuroscience, Economics, Statistics, Advertising, Web Analytics, and more.
11.4 Pandas Documentation¶
In [1]:
from IPython.display import YouTubeVideo
YouTubeVideo('CmorAWRsCAw',width=900, height=500)
Out[1]:
In [2]:
from IPython.display import YouTubeVideo
YouTubeVideo('F6kmIpWWEdU',width=900, height=500)
Out[2]:
11.5 Import Python Library¶
In [3]:
import pandas as pd
import numpy as np
import os
import glob
from glob import glob
11.6 Pandas Version¶
In [4]:
pd.__version__
Out[4]:
- But if you also need to know the versions of pandas' dependencies, you can use the show_versions() function:
In [5]:
pd.show_versions()
11.7 Create Data Frame¶
In [6]:
from IPython.display import YouTubeVideo
YouTubeVideo('-Ov1N1_FbP8',width=900, height=500)
Out[6]:
There are many ways to do this, but my favorite ways are;
In [7]:
from IPython.display import YouTubeVideo
YouTubeVideo('3k0HbcUGErE',width=900, height=500)
Out[7]:
1- Create Data Frame Using Dictionary¶
Format-1¶
In [8]:
weather=pd.DataFrame({
'Day':['1/1/2019','1/2/2019','1/3/2019','1/4/2019'],
'Temperature':[30,32,34,36],
'Windspeed':[6,7,10,12],
'Event':['Rain','Sunny','Rain','Sunny']
})
weather
Out[8]:
Format-2 (from_dict)¶
- More information
- Construct DataFrame from dict of array-like or dicts.
In [9]:
weather=pd.DataFrame.from_dict({
'Day':['1/1/2019','1/2/2019','1/3/2019','1/4/2019'],
'Temperature':[30,32,34,36],
'Windspeed':[6,7,10,12],
'Event':['Rain','Sunny','Rain','Sunny']
})
weather
Out[9]:
2- Create Data Frame Using List of Tuple¶
Format-1¶
In [10]:
weather=pd.DataFrame([
('1/1/2019',30,6,'Rain'),
('1/2/2019',32,7,'Sunny'),
('1/3/2019',34,10,'Rain'),
('1/4/2019',36,12,'Sunny')],
columns=["Day","Temperature","Windspeed","Event"])
weather
Out[10]:
Format-2 (from_records)¶
- More information
- Convert structured or record ndarray to DataFrame
In [11]:
sales = pd.DataFrame.from_records([('Jones LLC', 150, 200, 50),
('Alpha Co', 200, 210, 90),
('Blue Inc', 140, 215, 95)],
columns = ['account', 'Jan', 'Feb', 'Mar'])
sales
Out[11]:
3- Create Data Frame Using List of Dictionary¶
Format-1¶
In [12]:
weather=pd.DataFrame([
{'Day':'1/1/2019','Temperature':30,'Windspeed':6,'Event':'Rain'},
{'Day':'1/2/2019','Temperature':32,'Windspeed':7,'Event':'Sunny'},
{'Day':'1/3/2019','Temperature':34,'Windspeed':8,'Event':'Sunny'},
{'Day':'1/4/2019','Temperature':36,'Windspeed':8,'Event':'Rain'}
])
weather
Out[12]:
Format-2¶
In [13]:
sales = pd.DataFrame.from_dict(
[{'account': 'Jones LLC', 'Jan': 150, 'Feb': 200, 'Mar': 140},
{'account': 'Alpha Co', 'Jan': 200, 'Feb': 210, 'Mar': 215},
{'account': 'Blue Inc', 'Jan': 50, 'Feb': 90, 'Mar': 95 }]
)
sales
Out[13]:
Solution-1¶
In [14]:
sales = sales[['account', 'Jan', 'Feb', 'Mar']]
sales
Out[14]:
Solution-2 (from_dict)¶
- Alternatively you could create your dictionary using python’s OrderedDict .
In [15]:
from collections import OrderedDict
sales = pd.DataFrame.from_dict(
OrderedDict([('account', ['Jones LLC', 'Alpha Co', 'Blue Inc']),
('Jan', [150, 200, 50]),
('Feb', [200, 210, 90]),
('Mar', [140, 215, 95]) ])
)
sales
Out[15]:
Solution-3 (from_items)¶
- More information
- (DEPRECATED) Construct a DataFrame from a list of tuples.
In [16]:
sales = pd.DataFrame.from_items(
[('account', ['Jones LLC', 'Alpha Co', 'Blue Inc']),
('Jan', [150, 200, 50]),
('Feb', [200, 210, 90]),
('Mar', [140, 215, 95]),
])
sales
Out[16]:
4- Create Data Frame Using Random Number¶
In [17]:
df= pd.DataFrame(np.random.rand(4, 8))
df
Out[17]:
5- Create a DataFrame from the clipboard¶
- More Information
- Let's say that you have some data stored in an Excel spreadsheet or a Google Sheet, and you want to get it into a DataFrame as quickly as possible.
- Just select the data and copy it to the clipboard. Then, you can use the read_clipboard() function to read it into a DataFrame:
In [18]:
df = pd.read_clipboard()
df
Out[18]:
- Keep in mind that if you want your work to be reproducible in the future, read_clipboard() is not the recommended approach.
empty data frame¶
- Indicator whether DataFrame is empty.
- True if DataFrame is entirely empty (no items), meaning any of the axes are of length 0.
- More Information
In [19]:
df=pd.DataFrame({'A' : []})
df
Out[19]:
- If we only have NaNs in our DataFrame, it is not considered empty! We will need to drop the NaNs to make the DataFrame empty
In [20]:
df = pd.DataFrame({'A' : [np.nan]})
df
Out[20]:
In [21]:
df=df.empty
df
Out[21]:
11.8 Import Data Frame in Pandas¶
In [22]:
from IPython.display import YouTubeVideo
YouTubeVideo('5_QXMwezPJE',width=900, height=500)
Out[22]:
We can import Following Format Files in Pandas
1- Create Data Frame Using *.csv File¶
Example-1¶
In [23]:
df= pd.read_csv('Weather.csv')
df
Out[23]:
Solution-1::Skip Row¶
In [24]:
df= pd.read_csv('Weather.csv',skiprows=1)
df
Out[24]:
Solution-2::Define Header Row¶
In [25]:
df= pd.read_csv('Weather.csv',header=1)
df
Out[25]:
Example-2¶
In [26]:
df= pd.read_csv('Weather_header.csv')
df
Out[26]:
Solution-1::Header set to None¶
In [27]:
df= pd.read_csv('Weather_header.csv',header=None)
df
Out[27]:
Solution-2::Set Header Name¶
In [28]:
df= pd.read_csv('Weather_header.csv',
names=['Date','Temperature',
'Windspeed','Event'])
df
Out[28]:
Set Header Name using list Method¶
In [29]:
df= pd.DataFrame(np.random.rand(4, 8),columns=list('abcdefgh'))
df
Out[29]:
Example-3¶
Import Only Few Rows From *.csv File¶
In [30]:
df= pd.read_csv('Weather1.csv',nrows=2)
df
Out[30]:
Import Only Few Colums Using Variable Name¶
In [31]:
df= pd.read_csv('Weather1.csv',usecols=['Date','Temperature'])
df
Out[31]:
Import Only Few Colums Using Variable Index¶
In [32]:
df= pd.read_csv('Weather1.csv',usecols=[0,3])
df
Out[32]:
Example 4¶
In [33]:
df= pd.read_csv('Family.csv')
df
Out[33]:
Solution::Skip Footer¶
In [34]:
df= pd.read_csv('Family.csv',skipfooter=1)
df
Out[34]:
In [35]:
df= pd.read_csv('Family.csv',skipfooter=1,engine='python')
df
Out[35]:
Example 5¶
In [36]:
from IPython.display import YouTubeVideo
YouTubeVideo('0uBirYFhizE',width=900, height=500)
Out[36]:
In [37]:
df= pd.read_csv('check.csv')
df
Out[37]:
Solution1::Assign Columns Name¶
In [38]:
df.columns = ['Name', 'Student ID','Marks']
df
Out[38]:
Solution2:: Rename¶
- More Information
- Alter axes labels
In [39]:
df= pd.read_csv('check.csv')
df.rename(columns={"Unnamed: 1":"Student ID"})
Out[39]:
Rename Column Name using Replace Method¶
- More Information
- Replace values given in to_replace with value.
In [40]:
df = pd.DataFrame({'col one':[100, 200], 'col two':[300, 400]})
df
Out[40]:
In [41]:
df.columns = df.columns.str.replace(' ', '_')
df
Out[41]:
Remame Column Name using add_prefix() Method¶
- More Information
- Prefix labels with string prefix.
In [42]:
df = pd.DataFrame({'col one':[100, 200], 'col two':[300, 400]})
df.add_prefix('X_')
Out[42]:
Remame Column Name using add_suffix() Method¶
- More Information
- Suffix labels with string suffix.
In [43]:
df = pd.DataFrame({'col one':[100, 200], 'col two':[300, 400]})
df.add_suffix('_Y')
Out[43]:
Import File from url¶
In [44]:
df= pd.read_html('https://github.com/justmarkham/pandas-videos/blob/master/data/titanic_test.csv')
In [45]:
type(df)
Out[45]:
In [46]:
df=df[0]
In [47]:
df.head()
Out[47]:
In [48]:
df=df.iloc[:,1:]
df.head()
Out[48]:
2- Create Data Frame Using *.tsv File¶
In [49]:
df = pd.read_table('chipotle.tsv')
df.head()
Out[49]:
In [50]:
df = pd.read_csv('chipotle.tsv',sep='\t')
df.head()
Out[50]:
3- read table from url¶
Example-1¶
In [51]:
df = pd.read_html('https://en.wikipedia.org/wiki/Pakistan',attrs={'class': 'wikitable'})
In [52]:
len(df)
Out[52]:
In [53]:
df[0]
Out[53]:
Example-2¶
In [54]:
df = pd.read_html('https://en.wikipedia.org/wiki/Pakistan', attrs={"class":"sortable wikitable"})
In [55]:
len(df)
Out[55]:
In [56]:
df[0]
Out[56]:
Example-3¶
In [57]:
df = pd.read_html('https://en.wikipedia.org/wiki/List_of_UFC_events',attrs={"id":"Scheduled_events"})
In [58]:
len(df)
Out[58]:
In [59]:
df[0].head()
Out[59]:
Example-4¶
In [60]:
df = pd.read_html('https://en.wikipedia.org/wiki/University_of_California,_Berkeley', attrs={"class":"infobox vcard"})
In [61]:
len(df)
Out[61]:
In [62]:
df[0].head()
Out[62]:
Example-5¶
In [63]:
df = pd.read_html('https://en.wikipedia.org/wiki/University_of_California,_Berkeley', attrs={"class":"infobox"})
In [64]:
len(df)
Out[64]:
In [65]:
df[0].head()
Out[65]:
Example-6¶
In [66]:
df = pd.read_html('https://www.esportsearnings.com/players',attrs={"class":"detail_list_table"},header=0)
In [67]:
len(df)
Out[67]:
In [68]:
df[0].head()
Out[68]:
4- Create Data Frame Using *.xlsx File¶
Example-1¶
In [69]:
df=pd.read_excel('WHO_ex.xlsx','WHO')
df.head()
Out[69]:
Get all sheet names¶
In [70]:
df = pd.ExcelFile('Weather_subject.xlsx')
sheet_names = df.sheet_names
sheet_names
Out[70]:
In [71]:
Weather = pd.read_excel(df, 'Weather')
student = pd.read_excel(df, 'Subject')
In [72]:
Weather
Out[72]:
In [73]:
student
Out[73]:
Display all sheets¶
In [74]:
for tab in sheet_names:
print('################################## ' + tab + ' ##################################')
dfall = pd.read_excel(df, tab)
print(dfall)
5- Fixed-width formatted lines¶
In [75]:
df=pd.read_fwf('KPK_Weather.prn',colspecs = [(0,63),(63,76),(76,81),(81,92),(92,102)],parse_dates=["Day"])
df
Out[75]:
6- Import Table From pdf file¶
Install Tabula¶
In [76]:
import sys
!{sys.executable} -m pip install tabula-py
import tabula¶
In [77]:
import tabula
from tabula import read_pdf
In [78]:
df = read_pdf("http://www.uncledavesenterprise.com/file/health/Food%20Calories%20List.pdf", pages='all', multiple_tables=True)
In [79]:
len(df)
Out[79]:
In [80]:
df[4].head()
Out[80]:
11.9 Export Data Frame From Pandas¶
In [81]:
from IPython.display import YouTubeVideo
YouTubeVideo('-0NwrcZOKh',width=900, height=500)
Out[81]:
We can Export Following Format Files in Pandas
Data Frame-1¶
In [82]:
student=pd.DataFrame({
'Name':['Umer','Ali','Ahmed','Abdullah'],
'Marks':[100,98,97,95],
'Result':['Pass','Pass','Pass','Pass'],
'Subject':['Math','Phy','Chem','Bio']
})
student
Out[82]:
Data Frame-2¶
In [83]:
weather=pd.DataFrame({
'day':['1/1/2019','1/2/2019','1/3/2019','1/4/2019'],
'temperature':[30,32,34,36],
'windspeed':[6,7,10,12],
'event':['Rain','Sunny','Rain','Sunny']
})
weather
Out[83]:
1- Write .csv Format File¶
- More Information
- Write DataFrame to a comma-separated values (csv) file
In [84]:
student.to_csv('Output1.csv')
Export without Index¶
In [85]:
student.to_csv('output2.csv',index=False)
Export (without Index)/Selected Columns¶
In [86]:
student.to_csv('output3.csv',
index=False,columns=['Name','Marks'])
Export File (Skip Header)¶
In [87]:
student.to_csv('output4.csv',index=False,header=False)
2- Write .xlsx Format File¶
- More Information
- Write DataFrame to an excel sheet
In [88]:
student.to_excel("output5.xlsx",sheet_name="Student")
Export Without Index, specific row and col no¶
In [89]:
student.to_excel("output6.xlsx",sheet_name="Student",
startrow=3,startcol=3,index=False)
Export multiple worksheets in the same workbook¶
In [90]:
with pd.ExcelWriter('output7.xlsx') as writer:
weather.to_excel(writer,sheet_name="Weather",index=False)
student.to_excel(writer,sheet_name="Subject",index=False)
Read Write Data From Database¶
In [91]:
from IPython.display import YouTubeVideo
YouTubeVideo('M-4EpNdlSuY',width=900, height=500)
Out[91]:
11.10 Convert the DataFrame to a dictionary¶
to_dict¶
In [92]:
df= pd.read_csv('Family.csv',skipfooter=1,engine='python')
df
Out[92]:
In [93]:
df.to_dict('series')
Out[93]:
In [94]:
df.to_dict('split')
Out[94]:
In [95]:
df.to_dict('index')
Out[95]:
In [96]:
from collections import OrderedDict, defaultdict
df.to_dict(into=OrderedDict)
Out[96]:
In [97]:
df.to_dict('records', into=defaultdict(list))
Out[97]:
blocks¶
- (Deprecated since version 0.21.0.) DataFramem blocks attribute has successfully returned a dictionary containing the data of the dataframe.
- Homogeneous columns are places in the same block.
In [98]:
df= pd.read_csv('Family.csv',skipfooter=1,engine='python')
df
Out[98]:
In [99]:
df.blocks
Out[99]:
11.11 Convert the DataFrame to a array¶
to_records()¶
- Convert DataFrame to a NumPy record array
In [100]:
df= pd.read_csv('Family.csv',skipfooter=1,engine='python')
df
Out[100]:
In [101]:
df.to_records()
Out[101]:
In [102]:
df.to_records(index=False)
Out[102]:
values¶
- More Information
- values Return a Numpy representation of the DataFrame.
- Only the values in the DataFrame will be returned, the axes labels will be removed.
- Warning: Pandas recommend using DataFrame.to_numpy() instead
In [103]:
import pandas as pd
df= pd.read_csv('Family.csv',skipfooter=1,engine='python')
df
Out[103]:
In [104]:
df.values
Out[104]:
to_numpy¶
In [105]:
df.to_numpy()
Out[105]:
array¶
In [106]:
df['Name'].array
Out[106]:
to_list¶
- Return a list of the values.
In [107]:
df = pd.DataFrame({'a':[1,2,3], 'b':[4,5,6]})
df
Out[107]:
In [108]:
df['a'].to_list()
Out[108]:
explode¶
- Transform each element of a list-like to a row, replicating the index values.
Example-1¶
In [109]:
df = pd.Series([[1, 2, 3], 'foo', [], [3, 4]])
In [110]:
df
Out[110]:
In [111]:
df.explode()
Out[111]:
Example-2¶
In [112]:
df=pd.DataFrame({'A':[1,2],'B':[[1,2],[1,2]]})
In [113]:
df
Out[113]:
In [114]:
df.explode('B')
Out[114]:
get_values¶
- More Information
- (DEPRECATED) Return an ndarray after converting sparse values to dense.
In [115]:
df= pd.read_csv('Family.csv',skipfooter=1,engine='python')
df
Out[115]:
In [116]:
df.get_values()
Out[116]:
11.12 General Operations on Pandas Data Frames¶
Head of the Data Frame¶
- More Informaion
- This function returns the first n rows for the object based on position.
- It is useful for quickly testing if your object has the right type of data in it.
In [117]:
df_who= pd.read_csv('WHO_csv.csv')
In [118]:
df_who.head()
Out[118]:
In [119]:
df_who.head(2)
Out[119]:
Tail of the Data Frame¶
- More Information
- Return the last n rows.
In [120]:
df_who.tail()
Out[120]:
In [121]:
df_who.tail(2)
Out[121]:
Sample of the Data Frame¶
- More Information
- Return a random sample of items from an axis of object.
In [122]:
df_who.sample(3)
Out[122]:
Shape of the Data Frame¶
- More Information
- Return a tuple representing the dimensionality of the DataFrame
Method-1¶
In [123]:
df_who.shape
Out[123]:
Method-2¶
In [124]:
rows,columns= df_who.shape
print(rows,columns)
In [125]:
print("No of rows in the WHO Data Set:")
print(rows)
print("No of columns in the WHO Data Set:")
print(columns)
Dimensions of the Data Frame¶
- More Information
- Return an int representing the number of axes / array dimensions.
- Return 1 if Series. Otherwise return 2 if DataFrame.
Example-1¶
In [126]:
df_who.ndim
Out[126]:
Example-2¶
In [127]:
s = pd.Series({'a': 1, 'b': 2, 'c': 3})
s
Out[127]:
In [128]:
s.ndim
Out[128]:
Size of the Data Frame¶
- More Information
- Number of elements in the array.
Example-1¶
In [129]:
df_who.size
Out[129]:
Example-2¶
In [130]:
s = pd.Series({'a': 1, 'b': 2, 'c': 3})
s
Out[130]:
In [131]:
s.size
Out[131]:
Get Variables Name of the Data Frame¶
Method-1¶
- The column labels of the DataFrame.
In [132]:
df_who.columns
Out[132]:
Method-2¶
In [133]:
df_who.keys()
Out[133]:
Method-3¶
In [134]:
df_who['Country'].name
Out[134]:
Index of the Data Frame¶
- The index (row labels) of the DataFrame.
In [135]:
df_who.index
Out[135]:
axes of the Data Frame¶
- More Information
- Return a list representing the axes of the DataFrame.
- It has the row axis labels and column axis labels as the only members.
- They are returned in that order.
In [136]:
df_who.axes
Out[136]:
Set Index to the specfic Column¶
- More Information
- Set the DataFrame index (row labels) using one or more existing columns
Example-1¶
In [137]:
from IPython.display import YouTubeVideo
YouTubeVideo('XaCSdr7pPmY',width=900, height=500)
Out[137]:
In [138]:
df_who.set_index('Region',inplace=True)
df_who
Out[138]:
Example-2¶
In [139]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.set_index(['Region','Country'],inplace=True)
df_who
Out[139]:
Re-Set Index¶
In [140]:
df_who.reset_index(['Region','Country'],inplace=True)
In [141]:
df_who.head()
Out[141]:
set_axis¶
- Assign desired index to given axis.
- Indexes for column or row labels can be changed by assigning a list-like or Index
- More Information
In [142]:
df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
df
Out[142]:
In [143]:
df.set_axis(['a', 'b', 'c'], axis='rows', inplace=True)
df
Out[143]:
In [144]:
df.set_axis(['A1','B1'], axis='columns', inplace=True)
df
Out[144]:
Why do some pandas commands end with parentheses (and others don't)?¶
In [145]:
from IPython.display import YouTubeVideo
YouTubeVideo('hSrDViyKWVk',width=900, height=500)
Out[145]:
11.13 Data Type¶
dtype¶
- More Information
- Return the dtypes in the DataFrame.
In [146]:
df_who= pd.read_csv('WHO_csv.csv')
In [147]:
df_who.dtypes
Out[147]:
In [148]:
df_who['Country'].dtype
Out[148]:
In [149]:
df_who['Country'].dtypes
Out[149]:
get_dtype_counts()¶
- More Information
- (DEPRECATED) Return counts of unique dtypes in this object.
In [150]:
df_who.get_dtype_counts()
Out[150]:
infer_objects¶
- More Information
- Attempt to infer better dtypes for object columns.
- Attempts soft conversion of object-dtyped columns, leaving non-object and unconvertible columns unchanged.
- The inference rules are the same as during normal Series/DataFrame construction.
In [151]:
df = pd.DataFrame({"A": ["a", 1, 2, 3]})
df
Out[151]:
In [152]:
df = df.iloc[1:]
df
Out[152]:
In [153]:
df.dtypes
Out[153]:
In [154]:
df.infer_objects().dtypes
Out[154]:
Convert strings to numbers¶
In [155]:
from IPython.display import YouTubeVideo
YouTubeVideo('V0AWyzVMf54',width=900, height=500)
Out[155]:
In [156]:
df = pd.DataFrame({'col_one':['1.1', '2.2', '3.3'],
'col_two':['4.4', '5.5', '6.6'],
'col_three':['7.7', '8.8', '-']})
df
Out[156]:
- These numbers are actually stored as strings, which results in object columns:
In [157]:
df.dtypes
Out[157]:
- In order to do mathematical operations on these columns, we need to convert the data types to numeric. You can use the astype() method on the first two columns:
- More Information
In [158]:
df.astype({'col_one':'float', 'col_two':'float'}).dtypes
Out[158]:
- However, this would have resulted in an error if you tried to use it on the third column, because that column contains a dash to represent zero and pandas doesn't understand how to handle it.
- Instead, you can use the to_numeric() function on the third column and tell it to convert any invalid input into NaN values:
In [159]:
pd.to_numeric(df.col_three, errors='coerce')
Out[159]:
- If you know that the NaN values actually represent zeros, you can fill them with zeros using the fillna() method:
In [160]:
pd.to_numeric(df.col_three, errors='coerce').fillna(0)
Out[160]:
- Finally, you can apply this function to the entire DataFrame all at once by using the apply() method:
In [161]:
df1=df.apply(pd.to_numeric, errors='coerce').fillna(0)
df1
Out[161]:
In [162]:
df1.dtypes
Out[162]:
- This one line of code accomplishes our goal, because all of the data types have now been converted to float:
Example-1¶
In [163]:
import pandas as pd
df= pd.read_csv('Weather1.csv')
df
Out[163]:
In [164]:
df.dtypes
Out[164]:
In [165]:
df= pd.read_csv('Weather1.csv',dtype = {"Temperature" : "float64","Windspeed" : "float64"})
df
Out[165]:
In [166]:
df.dtypes
Out[166]:
Example-2¶
In [167]:
df= pd.read_csv('Weather1.csv',parse_dates=['Date'],dtype = {"Temperature" : "float64","Windspeed" : "float64"})
df
Out[167]:
In [168]:
df.dtypes
Out[168]:
In [169]:
from IPython.display import YouTubeVideo
YouTubeVideo('P_q0tkYqvSk',width=900, height=500)
Out[169]:
ftypes¶
- More Information
- (DEPRECATED) Return the ftypes (indication of sparse/dense and dtype) in DataFrame.
- This returns a Series with the data type of each column.
- The result’s index is the original DataFrame’s columns.
- Columns with mixed types are stored with the object dtype
In [170]:
df_who.ftypes
Out[170]:
get_ftype_counts()¶
- More Information
- Deprecated since version 0.23.0.
In [171]:
df_who.get_ftype_counts()
Out[171]:
Select columns by data type¶
- More Information
- Return a subset of the DataFrame’s columns based on the column dtypes.
- Let's say you need to select only the numeric columns. You can use the select_dtypes() method:
In [172]:
df_who.select_dtypes(include='number').head()
Out[172]:
- This includes both int and float columns.
In [173]:
df_who.select_dtypes(include='float64').head()
Out[173]:
In [174]:
df_who.select_dtypes(include='int64').head()
Out[174]:
In [175]:
df_who.select_dtypes(include='object').head()
Out[175]:
- You can tell it to include multiple data types by passing a list:
In [176]:
df_who.select_dtypes(include=['int64', 'object']).head()
Out[176]:
- You can also tell it to exclude certain data types:
In [177]:
df_who.select_dtypes(exclude='number').head()
Out[177]:
Date Time Data Type¶
In [178]:
df= pd.read_csv("DateIssue.csv")
df
Out[178]:
In [179]:
type(df.Date[0])
Out[179]:
Solution¶
In [180]:
df= pd.read_csv("DateIssue.csv",parse_dates=['Date'])
df
Out[180]:
In [181]:
type(df.Date[0])
Out[181]:
memory_usage¶
In [182]:
from IPython.display import YouTubeVideo
YouTubeVideo('wDYDYGyN_cw',width=900, height=500)
Out[182]:
In [183]:
df_who.memory_usage()
Out[183]:
In [184]:
df_who.memory_usage(index=False)
Out[184]:
- Use a Categorical for efficient storage of an object-dtype column with many repeated values.
In [185]:
df_who['Region'].astype('category').memory_usage(deep=True)
Out[185]:
In [186]:
df_who['Region'].astype('category').memory_usage(deep=False)
Out[186]:
nbytes¶
In [187]:
df_who['Country'].nbytes
Out[187]:
11.14 Summary of the Missing Values¶
In [188]:
from IPython.display import YouTubeVideo
YouTubeVideo('fCMrO_VzeL8',width=900, height=500)
Out[188]:
Info¶
- More Information
- Print a concise summary of a DataFrame.
- This method prints information about a DataFrame including the index dtype and column dtypes, non-null values and memory usage.
In [189]:
df_who= pd.read_csv('WHO_csv.csv')
In [190]:
df_who.info()
# df_who.info(verbose=True)
In [191]:
df_who.info(verbose=False)
isnull¶
- More Information
- Detect missing values.
In [192]:
df_who.isnull().head()
Out[192]:
In [193]:
df_who.isnull().sum()
Out[193]:
isna¶
- More Information
- Detect missing values.
In [194]:
df_who.isna().head()
Out[194]:
In [195]:
df_who.isna().sum()
Out[195]:
notnull¶
- More Information
- Detect existing (non-missing) values.
In [196]:
df_who.notnull().head()
Out[196]:
In [197]:
df_who.notnull().sum()
Out[197]:
notna¶
- More Information
- Detect existing (non-missing) values
In [198]:
df_who.notna().head()
Out[198]:
In [199]:
df_who.notna().sum()
Out[199]:
hasnans¶
In [200]:
df_who['PrimarySchoolEnrollmentMale'].hasnans
Out[200]:
In [201]:
df_who['Region'].hasnans
Out[201]:
11.15 Statistical Summary of the Data Frame¶
In [202]:
df_who= pd.read_csv('WHO_csv.csv')
Find sum¶
- More Information
- Return the sum of the values for the requested axis
In [203]:
df_who.sum()
Out[203]:
Find count¶
- Count non-NA cells for each column or row.
In [204]:
df_who.count()
Out[204]:
Find Max¶
- More Information
- This method returns the maximum of the values in the object.
In [205]:
df_who.max()
Out[205]:
Find Min¶
- More Information
- This method returns the minimum of the values in the object.
In [206]:
df_who.min()
Out[206]:
Find Mean¶
- More Information
- Return the mean of the values for the requested axis
In [207]:
df_who.mean()
Out[207]:
Find Median¶
- More Information
- Return the median of the values for the requested axis
In [208]:
df_who.median()
Out[208]:
Find Mode¶
In [209]:
df = pd.DataFrame({'A': [2, 2, 1, 2, 1, 2, 3]})
In [210]:
df.mode()
Out[210]:
Find Standard Deviation¶
- More Information
- Return sample standard deviation over requested axis.
In [211]:
df_who.std()
Out[211]:
Find kurtosis¶
- Return unbiased kurtosis over requested axis using Fisher’s definition of kurtosis (kurtosis of normal == 0.0).
- Normalized by N-1
Method-1¶
In [212]:
df_who.kurt()
Out[212]:
Method-2¶
In [213]:
df_who.kurtosis()
Out[213]:
Find Mean absolute deviation (MAD)¶
- More Information
- Return the mean absolute deviation of the values for the requested axis
In [214]:
df_who.mad(axis = 0)
Out[214]:
In [215]:
df_who.mad()
Out[215]:
Find standard error of the mean¶
- More Information
- Return unbiased standard error of the mean over requested axis.
In [216]:
df_who.sem()
Out[216]:
Find variance¶
- More Information
- Return unbiased variance over requested axis.
In [217]:
df_who.var()
Out[217]:
Find skew¶
- More Information
- Return unbiased skew over requested axis Normalized by N-1
In [218]:
df_who.skew()
Out[218]:
Find covariance¶
- More Information
- Compute pairwise covariance of columns, excluding NA/null values
In [219]:
df_who.cov()
Out[219]:
Find correlation¶
- Compute pairwise correlation of columns, excluding NA/null values
- More Information
In [220]:
from IPython.display import YouTubeVideo
YouTubeVideo('sCkS-0kIRCE',width=900, height=500)
Out[220]:
In [221]:
df_who.corr(method='pearson')
Out[221]:
other methods are available in Pandas are;
- pearson : standard correlation coefficient
- kendall : Kendall Tau correlation coefficient
- spearman : Spearman rank correlation
Find corrwith¶
- More Information
- Compute pairwise correlation between rows or columns of two DataFrame objects.
In [222]:
df1 = pd.DataFrame({"A":[1, 5, 7, 8],
"B":[5, 8, 4, 3],
"C":[10, 4, 9, 3]})
In [223]:
df2 = pd.DataFrame({"A":[5, 3, 6, 4],
"B":[11, 2, 4, 3],
"C":[4, 3, 8, 5]})
- To find the correlation among the
- columns of dfcw1 and dfcw2 along the row axis
In [224]:
df1.corrwith(df2, axis = 0)
Out[224]:
In [225]:
df1.corrwith(df2, axis = 1)
Out[225]:
Find quantile¶
In [226]:
df_who.quantile([0.25,0.50,0.75,0.100], numeric_only=True)
Out[226]:
Apply Count Fucntion in the row¶
In [227]:
from IPython.display import YouTubeVideo
YouTubeVideo('PtO3t6ynH-8',width=900, height=500)
Out[227]:
In [228]:
spl2= pd.read_csv('Scopus_1926-1950.csv',encoding='latin-1')
# Preprocessing
# Remove Space between Author(s)ID
spl2['Author(s)ID'] = spl2['Author(s)ID'].str.replace(" ","")
# Remove Author(s)ID end with ;
spl2['Author(s)ID'] = spl2['Author(s)ID'].str.rstrip(';')
spl2 = spl2.join(spl2['Author(s)ID'].str.split(';', expand=True).add_prefix('Author_'))
spl2.head()
Out[228]:
In [229]:
spl2.keys()
Out[229]:
In [230]:
spl2['AuthorCounts']=spl2.iloc[:,19:].count(axis=1)
spl2.head()
Out[230]:
Describe¶
In [231]:
from IPython.display import YouTubeVideo
YouTubeVideo('B-r9VuK80dk',width=900, height=500)
Out[231]:
- More Information
- Generates descriptive statistics that summarize the central tendency, dispersion and shape of a dataset’s distribution, excluding NaN values.
In [232]:
df_who.describe()
Out[232]:
In [233]:
df_who.describe(include='all')
Out[233]:
In [234]:
df_who['Population'].describe()
Out[234]:
In [235]:
df_who[['Population','Over60']].describe()
Out[235]:
In [236]:
df_who.describe(include=['object'])
Out[236]:
In [237]:
df_who.describe().loc['min':'max']
Out[237]:
In [238]:
df_who.describe().loc['min':'max', 'Under15':'ChildMortality']
Out[238]:
11.16 Pandas and Pandas Profiling to analyze data¶
- Let's say that you've got a new dataset, and you want to quickly explore it without too much work. There's a separate package called pandas-profiling that is designed for this purpose.
- First you have to install it using conda or pip. Once that's done, you import pandas_profiling:
- You also install pandas-profiling in Jupter Notebook using following command.
In [239]:
from IPython.display import YouTubeVideo
YouTubeVideo('EaHWjkEPHr8',width=900, height=500)
Out[239]:
Pandas Profiling Installation¶
In [240]:
import sys
!{sys.executable} -m pip install pandas-profiling
Then, simply run the ProfileReport() function and pass it any DataFrame. It returns an interactive HTML report:
- The first section is an overview of the dataset and a list of possible issues with the data.
- The next section gives a summary of each column. You can click "toggle details" for even more information.
- The third section shows a heatmap of the correlation between columns.
- And the fourth section shows the head of the dataset.
In [241]:
import pandas as pd
import pandas_profiling
df_who= pd.read_csv('WHO_csv.csv')
In [242]:
pandas_profiling.ProfileReport(df_who)
Out[242]:
11.17 Slicing Subsets of Rows and Columns in Pandas¶
In [243]:
from IPython.display import YouTubeVideo
YouTubeVideo('zxqjeyKP2Tk',width=900, height=500)
Out[243]:
In [244]:
from IPython.display import YouTubeVideo
YouTubeVideo('OYZNk7Z9s6I',width=900, height=500)
Out[244]:
In [245]:
from IPython.display import YouTubeVideo
YouTubeVideo('xvpNA7bC8cs',width=900, height=500)
Out[245]:
at¶
- More Information
- Access a single value for a row/column label pair.
In [246]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.head()
Out[246]:
In [247]:
df_who.at[1, 'Country']
Out[247]:
In [248]:
df_who.at[3, 'Population']=780
In [249]:
df_who.head()
Out[249]:
- Get value within a Series
In [250]:
df_who.loc[3].at['Population']
Out[250]:
iat¶
- More Information
- Access a single value for a row/column pair by integer position.
- Similar to iloc, in that both provide integer-based lookups.
- Use iat if you only need to get or set a single value in a DataFrame or Series.
- Get value at specified row/column pair
In [251]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.head()
Out[251]:
In [252]:
df_who.iat[0, 0]
Out[252]:
In [253]:
df_who.iat[2, 3]=880
In [254]:
df_who.head()
Out[254]:
- Get value within a series
In [255]:
df_who.loc[0].iat[0]
Out[255]:
ix¶
- A primarily label-location based indexer, with integer position fallback.
- Deprecated
In [256]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.head()
Out[256]:
In [257]:
df_who.ix[10:20, ['Country','Over60']]
Out[257]:
In [258]:
df_who.ix[10:15,]
Out[258]:
In [259]:
df_who.ix[:4, 1:3]
Out[259]:
In [260]:
df_who.ix[[1,3,5], [1,8]]
Out[260]:
filter¶
- Subset rows or columns of dataframe according to labels in the specified index
- More Information-1
- More Information-2
In [261]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.head()
Out[261]:
In [262]:
df_who.filter(['Country', 'CellularSubscribers','Population']).head()
Out[262]:
In [263]:
df_who.filter(regex ='[cC]').head()
Out[263]:
In [264]:
df_who.filter(like ='Enr').head()
Out[264]:
Subset of Each Rows and Columns¶
In [265]:
df_who= pd.read_csv('WHO_csv.csv')
df_who[:]
Out[265]:
Subset of Specific Rows¶
In [266]:
df_who[10:14]
Out[266]:
loc and iloc¶
- loc: Access a group of rows and columns by label(s) or a boolean array.
- iloc: Purely integer-location based indexing for selection by position.
- More Information
Subset Specific Rows(Using iloc)¶
In [267]:
df_who.iloc[10:14]
Out[267]:
Subset Specific Rows(Using loc)¶
In [268]:
df_who.loc[[2,4,6]]
Out[268]:
Subset of Specific Columns(Using iloc)¶
In [269]:
df_who.iloc[:,1:4]
Out[269]:
Subset Specific Rows and Columns (Using iloc)¶
In [270]:
df_who.iloc[14:25, 1:4]
Out[270]:
In [271]:
df_who.Country
Out[271]:
Method-2¶
In [272]:
df_who['Country']
Out[272]:
Subset Specific Column(Using Variable Name)-Mutipule Variable¶
In [273]:
df_who[['Country', 'Region', 'Population']]
Out[273]:
subset Specific Rows and Columns(Using Variable Name & loc)¶
In [274]:
df_who.loc[1:4,['Country', 'Region', 'Population']]
Out[274]:
In [275]:
df_who.loc[[2,4,50,52],['Country', 'Region', 'Population']]
Out[275]:
Example¶
In [276]:
df_who.loc[df_who.Population>360000,['Country']]
Out[276]:
Example¶
In [277]:
df_who.loc[df_who.Population>360000,['Country','Population']]
Out[277]:
Reverse row order¶
In [278]:
df_who.loc[::-1]
Out[278]:
- What if you also wanted to reset the index so that it starts at zero?
- You would use the reset_index() method and tell it to drop the old index entirely:
- More Information
- For DataFrame with multi-level index, return new DataFrame with labeling information in the columns under the index names, defaulting to ‘level_0’, ‘level_1’, etc.
reset_index()¶
In [279]:
df_who.loc[::-1].reset_index(drop=True)
Out[279]:
- As you can see, the rows are in reverse order but the index has been reset to the default integer index.
Reverse column order¶
In [280]:
df_who.loc[:, ::-1]
Out[280]:
idxmax¶
- Return index of first occurrence of maximum over requested axis.
- NA/null values are excluded.
In [281]:
from IPython.display import YouTubeVideo
YouTubeVideo('egdfGJaBIh0',width=900, height=500)
Out[281]:
In [282]:
df = pd.DataFrame({"A":[4, 5, 2, 6],
"B":[11, 2, 115, 8],
"C":[1, 8, 66, 4]})
df
Out[282]:
In [283]:
#df.idxmax(axis=0)
df.idxmax()
#0='rows'
Out[283]:
In [284]:
df.loc[df.idxmax(axis=0)]
Out[284]:
In [285]:
df.idxmax(axis=1)
#1='column'
Out[285]:
idxmin¶
- Return index of first occurrence of minimum over requested axis.
- NA/null values are excluded.
In [286]:
df = pd.DataFrame({"A":[4, 5, 2, 6],
"B":[11, 2, 115, 8],
"C":[1, 8, 66, 4]})
df
Out[286]:
In [287]:
#df.idxmin(axis=0)
df.idxmin()
#0='rows'
Out[287]:
In [288]:
df.idxmin(axis=1)
#1='colmun'
Out[288]:
first_valid_index¶
- first_valid_index: Return index for first non-NA/null value.
In [289]:
df = pd.DataFrame({
"A1":[np.NaN,np.NaN,np.NaN,5,6,np.NaN,np.NaN],
})
df
Out[289]:
In [290]:
df.first_valid_index()
Out[290]:
last_valid_index¶
- last_valid_index: Return index for last non-NA/null value.
In [291]:
df = pd.DataFrame({
"A1":[np.NaN,np.NaN,np.NaN,5,6,np.NaN,np.NaN],
})
df
Out[291]:
In [292]:
df.last_valid_index()
Out[292]:
transpose¶
- Transpose index and columns.
- More Information-1
- More Information-2
In [293]:
df=pd.read_csv('rep.csv')
df
Out[293]:
Method-1¶
In [294]:
df.T
Out[294]:
Method-2¶
In [295]:
df.transpose()
Out[295]:
xs¶
- Returns a cross-section (row(s) or column(s)) from the Series/DataFrame.
- Defaults to cross-section on the rows (axis=0).
- More Information
In [296]:
df=pd.read_csv('rep.csv')
df.xs(1)
Out[296]:
In [297]:
df.xs('Name',axis=1)
Out[297]:
slice_shift¶
- Equivalent to shift without copying data.
- More Information
In [298]:
df = pd.DataFrame({"A":[1, 2, 3, 4, 5],
"B":[10, 20, 30, 40, 50],
"C":[11, 22, 33, 44, 55],
"D":[12, 24, 51, 36, 2]})
df
Out[298]:
In [299]:
df.slice_shift(2)
Out[299]:
In [300]:
df.slice_shift(2, axis = 0)
Out[300]:
In [301]:
df.slice_shift(2, axis = 1)
Out[301]:
In [302]:
df.slice_shift(-2, axis = 1)
Out[302]:
truncate¶
- Truncate a Series or DataFrame before and after some index value.
- More Information
In [303]:
df = pd.DataFrame({'A': ['a', 'b', 'c', 'd', 'e'],
'B': ['f', 'g', 'h', 'i', 'j'],
'C': ['k', 'l', 'm', 'n', 'o']})
df
Out[303]:
In [304]:
df.truncate(before=2, after=3)
Out[304]:
In [305]:
df.truncate(before="A", after="B", axis="columns")
Out[305]:
In [306]:
df['A'].truncate(before=2, after=4)
Out[306]:
11.18 Conditional Filtering in Pandas¶
In [307]:
from IPython.display import YouTubeVideo
YouTubeVideo('2AFGPdNn4FM',width=900, height=500)
Out[307]:
In [308]:
import pandas as pd
df_who= pd.read_csv('WHO_csv.csv')
Example-1(a)¶
- Filter Population geater than 360000.
Method-1¶
In [309]:
df_who[df_who.Population>360000]
Out[309]:
Method-2¶
In [310]:
df_who[df_who['Population'].gt(360000)]
Out[310]:
Example-1(b)¶
- Filter Population less than 360000.
Method-1¶
In [311]:
df_who[df_who.Population<360000]
Out[311]:
Method2¶
In [312]:
df_who[df_who['Population'].lt(360000)]
Out[312]:
Example-1(c)¶
- Filter Population equal to 28541.
Method-1¶
In [313]:
df_who[df_who.Population==28541]
Out[313]:
Method-2¶
In [314]:
df_who[df_who['Population'].eq(28541)]
Out[314]:
Example-1(d)¶
- Filter Population not equal to 28541.
Method-1¶
In [315]:
df_who[df_who.Population!=28541]
Out[315]:
Method-2¶
In [316]:
df_who[df_who['Population'].ne(28541)]
Out[316]:
Example-1(e)¶
Method-1¶
In [317]:
df_who[df_who.Population>=318000]
Out[317]:
Method-2¶
In [318]:
df_who[df_who['Population'].ge(318000)]
Out[318]:
Example-1(f)¶
Method-1¶
In [319]:
df_who[df_who.Population<=10000]
Out[319]:
Method-2¶
In [320]:
df_who[df_who['Population'].le(10000)]
Out[320]:
Example-2¶
Method-1¶
In [321]:
df_who[df_who.Population==df_who.Population.max()]
Out[321]:
Method-2¶
In [322]:
df_who[df_who.Population==df_who['Population'].max()]
Out[322]:
Note:¶
- Statment-1: df_who[df_who.Population==df_who.Population.max()]
- Statment-2: df_who[df_who.Population==df_who['Population'].max()]
- Statment-1=Statment-2
Example-3¶
In [323]:
from IPython.display import YouTubeVideo
YouTubeVideo('YPItfQ87qjM',width=900, height=500)
Out[323]:
- Filter Population>=20000 and LifeExpectancy=60.
Method-1¶
In [324]:
df_who[(df_who.Population>=20000) & (df_who.LifeExpectancy==60)]
Out[324]:
Method-2¶
In [325]:
df_who[df_who['Population'].ge(20000)& (df_who['LifeExpectancy'].eq(60))]
Out[325]:
Example-4¶
contains¶
In [326]:
df_who[df_who.Country.str.contains('istan')]
Out[326]:
Example-5¶
startswith¶
In [327]:
df_who[df_who['Country'].str.startswith('A')]
Out[327]:
Example-6¶
endswith¶
In [328]:
df_who[df_who['Country'].str.endswith('n')]
Out[328]:
Example-7¶
- Max Population Data Frame (Specific Columns)
In [329]:
df_who[['Region','CellularSubscribers','Population']][df_who.Population==df_who['Population'].max()]
Out[329]:
Example-8¶
unique¶
- Unique Values in a Single Variable
In [330]:
df_who.Region.unique()
Out[330]:
nunique¶
- More Information
- Return Series with number of distinct observations over requested axis
In [331]:
df_who.Region.nunique()
Out[331]:
- If we wanted to filter the DataFrame to only show Region with the 'africa' or 'americas' or 'south-east asia', we could use multiple conditions separated by the "or" operator:
In [332]:
df_who[(df_who.Region == 'Africa') |
(df_who.Region == 'Americas') |
(df_who.Region == 'South-East Asia')]
Out[332]:
isin¶
- However, you can actually rewrite this code more clearly by using the isin() method and passing it a list of Region:
- Return boolean DataFrame showing whether each element in the DataFrame is contained in values.
- More Information
In [333]:
df_who[df_who.Region.isin(['Africa', 'Americas', 'South-East Asia'])]
Out[333]:
- And if you want to reverse this filter, so that you are excluding (rather than including) those three Region, you can put a tilde in front of the condition:
In [334]:
df_who[~df_who.Region.isin(['Africa', 'Americas', 'South-East Asia'])]
Out[334]:
- This works because tilde is the "not" operator in Python.
Filter a DataFrame by largest/smallest categories¶
- Let's say that you needed to filter the WHO DataFrame by Region, but only include the 3 largest Region.
- We'll start by taking the value_counts() of genre and saving it as a Series called counts:
value_counts()¶
In [335]:
from IPython.display import YouTubeVideo
YouTubeVideo('QTVTq8SPzxM',width=900, height=500)
Out[335]:
In [336]:
df_who.Region.value_counts()
Out[336]:
- The Series method nlargest() makes it easy to select the 3 largest values in this Series:
- Return the first n rows ordered by columns in descending order.
- More Information
sort_index¶
In [337]:
from IPython.display import YouTubeVideo
YouTubeVideo('15q-is8P_H4',width=900, height=500)
Out[337]:
Example-1¶
In [338]:
df_who.Region.value_counts().sort_index()
Out[338]:
Example-2¶
In [339]:
df_who.Region.value_counts(normalize=True).sort_index()
Out[339]:
Example-3¶
In [340]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.head()
Out[340]:
In [341]:
df_who.sort_index(axis=1, inplace=True)
In [342]:
df_who.head()
Out[342]:
nlargest()¶
In [343]:
df_who.Region.value_counts().nlargest(n=3)
Out[343]:
- And all we actually need from this Series is the index:
In [344]:
df_who.Region.value_counts().nlargest(n=3).index
Out[344]:
In [345]:
df_who[df_who.Region.isin(df_who.Region.value_counts().nlargest(3).index)]
Out[345]:
In [346]:
df_who[~df_who.Region.isin(df_who.Region.value_counts().nlargest(3).index)]
Out[346]:
- we will use nlargest to select the three rows having the largest values in column “Population”.
In [347]:
df_who.nlargest(3, 'Population')
Out[347]:
- When using keep='last', ties are resolved in reverse order:
In [348]:
df_who.nlargest(3, 'LifeExpectancy', keep='last')
Out[348]:
- When using keep='all', all duplicate items are maintained:
In [349]:
df_who.nlargest(3, 'LifeExpectancy', keep='all')
Out[349]:
nsmallest()¶
- More Information
- Get the rows of a DataFrame sorted by the n smallest values of columns.
In [350]:
df_who.Region.value_counts().nsmallest(3)
Out[350]:
- And all we actually need from this Series is the index:
In [351]:
df_who.Region.value_counts().nsmallest(3).index
Out[351]:
In [352]:
df_who[df_who.Region.isin(df_who.Region.value_counts().nsmallest(3).index)]
Out[352]:
In [353]:
df_who[~df_who.Region.isin(df_who.Region.value_counts().nsmallest(3).index)]
Out[353]:
In [354]:
df_who.nsmallest(3, 'Population')
Out[354]:
between¶
In [355]:
df_who= pd.read_csv('WHO_csv.csv')
In [356]:
df_who[df_who['Population'].between(1, 500)]
Out[356]:
11.19 Arithmetic Operations¶
In [357]:
df = pd.DataFrame({
'a': [4, 5, 6, 7],
'b': [10, 20, 30, 40],
'c': [100, 50, -30, -50]
})
df
Out[357]:
add¶
- More Information
- Addition of dataframe and other, element-wise (binary operator add).
Example-1¶
Method-1¶
In [358]:
df+1
Out[358]:
Method-2¶
In [359]:
df.add(1)
Out[359]:
In [360]:
df + [1, 1,1]
Out[360]:
Method-2¶
In [361]:
df.add([1,1,1])
Out[361]:
Exaple-3¶
In [362]:
df.add([1,2,3], axis='columns')
Out[362]:
Example-4 (add two data farme)¶
In [363]:
df1 = pd.DataFrame({
'a': [4, 5, 6, 7],
'b': [10, 20, 30, 40],
'c': [100, 50, -30, -50]
})
df1
Out[363]:
In [364]:
df2 = pd.DataFrame({
'a': [1, 2, 3, 4],
'b': [5, 6, 7, 8],
'c': [9, 10, 11, 12]
})
df2
Out[364]:
Method-1¶
In [365]:
df1+df2
Out[365]:
Method-2¶
In [366]:
df1.add(df2)
Out[366]:
subtract¶
- Subtraction of dataframe and other, element-wise (binary operator sub).
- More Information1
- More Information2
In [367]:
df = pd.DataFrame({
'a': [4, 5, 6, 7],
'b': [10, 20, 30, 40],
'c': [100, 50, -30, -50]
})
df
Out[367]:
In [368]:
df-1
Out[368]:
Method-2¶
In [369]:
df.sub(1)
Out[369]:
Method-3¶
In [370]:
df.subtract(1)
Out[370]:
In [371]:
df - [1, 1,1]
Out[371]:
Mehtod-2¶
In [372]:
df.sub([1, 1,1])
Out[372]:
Method-3¶
In [373]:
df.subtract([1, 1,1])
Out[373]:
In [374]:
df.sub([1, 2,3], axis='columns')
Out[374]:
Method-2¶
In [375]:
df.subtract([1, 2,3], axis='columns')
Out[375]:
Example-4 (sub two data farme)¶
In [376]:
df1 = pd.DataFrame({
'a': [4, 5, 6, 7],
'b': [10, 20, 30, 40],
'c': [100, 50, -30, -50]
})
df1
Out[376]:
In [377]:
df2 = pd.DataFrame({
'a': [1, 2, 3, 4],
'b': [5, 6, 7, 8],
'c': [9, 10, 11, 12]
})
df2
Out[377]:
Method-1¶
In [378]:
df1-df2
Out[378]:
Method-2¶
In [379]:
df1.sub(df2)
Out[379]:
Method-3¶
In [380]:
df1.subtract(df2)
Out[380]:
shift¶
- Shift index by desired number of periods with an optional time freq
- More Information
Example-1¶
In [381]:
df= pd.read_csv('egg_price.csv')
df
Out[381]:
In [382]:
df= pd.read_csv('egg_price.csv',parse_dates=['Date'],index_col='Date')
df
Out[382]:
In [383]:
#shift the Price of eggs previous day
df['previous_day']=df['Price'].shift(1)
df
Out[383]:
In [384]:
#shift the Price of eggs next day
df['next_day']=df['Price'].shift(-1)
df
Out[384]:
In [385]:
df['1daychange']=df['previous_day']-df['next_day']
df
Out[385]:
In [386]:
df['5days%return']= (df['Price']-df['Price'].shift(5))*100/df['Price'].shift(5)
df
Out[386]:
diff¶
- More Information
- First discrete difference of element.
- Calculates the difference of a DataFrame element compared with another element in the DataFrame (default is the element in the same column of the previous row).
In [387]:
df = pd.DataFrame({'a': [1, 2, 3, 4, 5, 6],
'b': [1, 1, 2, 3, 5, 8],
'c': [1, 4, 9, 16, 25, 36]})
df
Out[387]:
In [388]:
df.diff()
Out[388]:
- Difference with previous column
In [389]:
df.diff(axis=1)
Out[389]:
- Difference with 3rd previous row
In [390]:
df.diff(periods=3)
Out[390]:
- Difference with following row
In [391]:
df.diff(periods=-1)
Out[391]:
multiply¶
- Multiplication of dataframe and other, element-wise (binary operator mul).
- More Information1
- More Information2
In [392]:
df = pd.DataFrame({
'a': [4, 5, 6, 7],
'b': [10, 20, 30, 40],
'c': [100, 50, -30, -50]
})
df
Out[392]:
In [393]:
df*2
Out[393]:
Method-2¶
In [394]:
df.mul(2)
Out[394]:
Method-3¶
In [395]:
df.multiply(2)
Out[395]:
In [396]:
df*[1,2,3]
Out[396]:
Method-2¶
In [397]:
df.mul([1,2,3])
Out[397]:
Method-3¶
In [398]:
df.multiply([1,2,3])
Out[398]:
In [399]:
df = pd.DataFrame({
'a': [4, 5, 6, 7],
'b': [10, 20, 30, 40],
'c': [100, 50, -30, -50]
})
df
Out[399]:
Method-1¶
In [400]:
df.mul([1,2,3],axis='columns')
Out[400]:
Method-2¶
In [401]:
df.multiply([1,2,3],axis='columns')
Out[401]:
Example-4 (Multiply two data farme)¶
In [402]:
df1 = pd.DataFrame({
'a': [4, 5, 6, 7],
'b': [10, 20, 30, 40],
'c': [100, 50, -30, -50]
})
df1
Out[402]:
In [403]:
df2 = pd.DataFrame({
'a': [1, 2, 3, 4],
'b': [5, 6, 7, 8],
'c': [9, 10, 11, 12]
})
df2
Out[403]:
Method-1¶
In [404]:
df1*df2
Out[404]:
Method-2¶
In [405]:
df1.mul(df2)
Out[405]:
Method-3¶
In [406]:
df1.multiply(df2)
Out[406]:
dot¶
- Matrix multiplication with DataFrame or Series objects.
Example-1¶
In [407]:
df1 = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
In [408]:
df1
Out[408]:
In [409]:
df2 = pd.DataFrame({"A":[5, 6],
"B":[7, 8]})
In [410]:
df2
Out[410]:
np.dot(df1, df2)
Example-2¶
In [411]:
df1 = pd.Series([7, 5, 6, 4, 9])
df1
Out[411]:
In [412]:
df2= pd.Series([1, 2, 3, 10, 2])
df2
Out[412]:
(7)(1) + (5)(2) + (6)(3) + (4)(10)+ (9)(2) = 7 + 10 + 18 + 40 + 18 = 93
In [413]:
df1.dot(df2)
Out[413]:
product¶
- Return the product of the values for the requested axis
- More Information1
- More Information2
In [414]:
df = pd.DataFrame({"A":[5, 6],
"B":[7, 8]})
df
Out[414]:
In [415]:
df.prod(axis = 0)
Out[415]:
In [416]:
df.prod(axis = 1)
Out[416]:
Method-2¶
In [417]:
df.product(axis = 0)
Out[417]:
In [418]:
df.product(axis = 1)
Out[418]:
divide¶
- More Information1
- More Information2
- More Information3
- More Information4
- Floating division of dataframe and other, element-wise
Example-1¶
Method-1¶
In [419]:
df = pd.DataFrame({"A":[2, 4],
"B":[6, 8]})
df
Out[419]:
In [420]:
df/2
Out[420]:
Method-2¶
In [421]:
df.div(2)
Out[421]:
Method-3¶
In [422]:
df.divide(2)
Out[422]:
Method-4¶
In [423]:
df.rdiv(2)
#2/df
Out[423]:
Example-2¶
In [424]:
df = pd.DataFrame({"A":[2, 4],
"B":[6, 8]})
df
Out[424]:
Method-1¶
In [425]:
df/[2,4]
Out[425]:
Method-2¶
In [426]:
df.div([2,4])
Out[426]:
Method-3¶
In [427]:
df.divide([2,4])
Out[427]:
Method-4¶
In [428]:
df.rdiv([2,4])
Out[428]:
Example-3¶
In [429]:
df = pd.DataFrame({"A":[2, 4],
"B":[6, 8]})
df
Out[429]:
Method-1¶
In [430]:
df.div([2,4],axis='columns')
Out[430]:
Method-2¶
In [431]:
df.divide([2,4],axis='columns')
Out[431]:
Method-3¶
In [432]:
df.rdiv([2,4],axis='columns')
Out[432]:
Example-4 (div Two Data Frames)¶
In [433]:
df1 = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
df1
Out[433]:
In [434]:
df2 = pd.DataFrame({"A":[5, 6],
"B":[7, 8]})
df2
Out[434]:
Method-1¶
In [435]:
df1/df2
Out[435]:
Method-2¶
In [436]:
df1.div(df2)
Out[436]:
Method-3¶
In [437]:
df1.divide(df2)
Out[437]:
Method-4¶
In [438]:
df1.rdiv(df2)
Out[438]:
floordiv¶
- Integer division of dataframe and other, element-wise (binary operator floordiv).
In [439]:
df = pd.DataFrame({"A":[5, 3, None, 4],
"B":[None, 2, 4, 3],
"C":[4, 3, 8, 5],
"D":[5, 4, 2, None]})
df
Out[439]:
In [440]:
df.floordiv(2, fill_value = 50)
Out[440]:
mod¶
- More Information
- Modulo of dataframe and other, element-wise (binary operator mod).
In [441]:
df= pd.DataFrame({"A":[5, 3, None, 4],
"B":[None, 2, 4, 3],
"C":[4, 3, 7, 5],
"D":[5, 4, 2, None]})
df
Out[441]:
In [442]:
df.mod(3)
Out[442]:
pow¶
- More Information
- Exponential power of dataframe and other, element-wise (binary operator pow).
Example-1¶
In [443]:
df = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
df
Out[443]:
In [444]:
df.pow(2)
Out[444]:
Example-2¶
In [445]:
df1 = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
In [446]:
df1
Out[446]:
In [447]:
df2 = pd.DataFrame({"A":[5, 6],
"B":[7, 8]})
In [448]:
df2
Out[448]:
In [449]:
df1.pow(df2)
Out[449]:
abs¶
- More Information
- Return a Series/DataFrame with absolute numeric value of each element.
- This function only applies to elements that are all numeric.
Example-1¶
In [450]:
df=pd.DataFrame({
'Temperature':[-30,32,-34,36],
'Windspeed':[6,7,10,-12]
})
df
Out[450]:
In [451]:
df['Windspeed'] = df['Windspeed'].abs()
df
Out[451]:
Example-2¶
In [452]:
df=pd.DataFrame({
'Temperature':[-30,32,-34,36,1.2 + 1j],
'Windspeed':[6,7,10,-12,1.2 + 1j]
})
df
Out[452]:
In [453]:
df=df.abs()
df
Out[453]:
round¶
- More Information
- Round a DataFrame to a variable number of decimal places
Example-1¶
In [454]:
df.round(0)
Out[454]:
Example-2¶
In [455]:
df.round({'Temperature': 0, 'Windspeed': 1})
Out[455]:
ceil¶
In [456]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.head()
Out[456]:
In [457]:
df_who['Over60']=df_who['Over60'].apply(np.ceil)
df_who.head()
Out[457]:
floor¶
In [458]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.head()
Out[458]:
In [459]:
df_who['Over60']=df_who['Over60'].apply(np.floor)
df_who.head()
Out[459]:
11.20 logical operations¶
eq¶
- Wrapper for flexible comparison methods eq
- eq() is used to compare every element of Caller series with passed series.
- It returns True for every element which is Equal to the element in passed series.
In [460]:
df1 = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
df1
Out[460]:
In [461]:
df2 = pd.DataFrame({"A":[1, 2],
"B":[3, 8]})
df2
Out[461]:
In [462]:
df1.eq(df2)
Out[462]:
equals¶
- Determines if two NDFrame objects contain the same elements. NaNs in the same location are considered equal.
In [463]:
df1 = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
df1
Out[463]:
In [464]:
df2 = pd.DataFrame({"A":[1, 2],
"B":[3, 8]})
df2
Out[464]:
In [465]:
df1.equals(df2)
Out[465]:
ge¶
- Wrapper for flexible comparison methods ge
- ge() is used to compare every element of Caller series with passed series.
- It returns True for every element which is Greater than or Equal to the element in passed series.
In [466]:
df1 = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
df1
Out[466]:
In [467]:
df2 = pd.DataFrame({"A":[1, 2],
"B":[3, 8]})
In [468]:
df1.ge(df2)
Out[468]:
gt¶
- Wrapper for flexible comparison methods gt
In [469]:
df1 = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
df1
Out[469]:
In [470]:
df2 = pd.DataFrame({"A":[1, 2],
"B":[3, 8]})
df2
Out[470]:
In [471]:
df1.gt(df2)
Out[471]:
le¶
- Wrapper for flexible comparison methods le
In [472]:
df1 = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
df1
Out[472]:
In [473]:
df2 = pd.DataFrame({"A":[1, 2],
"B":[3, 8]})
df2
Out[473]:
In [474]:
df1.le(df2)
Out[474]:
lt¶
- Wrapper for flexible comparison methods lt
In [475]:
df1 = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
df1
Out[475]:
In [476]:
df2 = pd.DataFrame({"A":[1, 2],
"B":[3, 8]})
df2
Out[476]:
In [477]:
df1.lt(df2)
Out[477]:
ne¶
- Wrapper for flexible comparison methods ne
In [478]:
df1 = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
df1
Out[478]:
In [479]:
df2 = pd.DataFrame({"A":[1, 2],
"B":[3, 8]})
df2
Out[479]:
In [480]:
df1.ne(df2)
Out[480]:
all any and bool¶
- All :Return whether all elements are True, potentially over an axis
- Any :Return whether any element is True over requested axis.
- bool: - Return the bool of a single element PandasObject.
- This must be a boolean scalar value, either True or False.
- Raise a ValueError if the PandasObject does not have exactly 1 element, or that element is not boolean.
- More Information1
- More Information2
- More Information3
In [481]:
df = pd.DataFrame()
df['x'] = [1,2,16]
df['y'] = [3,4,5]
In [482]:
df['z']=df['x'] < df['y']
df
Out[482]:
In [483]:
df['z'].all()
Out[483]:
In [484]:
df['z'].any()
Out[484]:
In [485]:
df['z'].bool
Out[485]:
11.21 Miscellaneous Operations¶
In [486]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.head()
Out[486]:
In [487]:
from IPython.display import YouTubeVideo
YouTubeVideo('bofaC0IckHo',width=900, height=500)
Out[487]:
Upper Case¶
In [488]:
df_who['Country']=df_who.Country.str.upper()
df_who.head()
Out[488]:
Lower Case¶
In [489]:
df_who['Region']=df_who.Region.str.lower()
df_who.head()
Out[489]:
capitalize¶
In [490]:
df = pd.Series(['lower', 'CAPITALS', 'this is a sentence', 'SwApCaSe'])
In [491]:
df.str.capitalize()
Out[491]:
title¶
In [492]:
df = pd.Series(['lower', 'CAPITALS', 'this is a sentence', 'SwApCaSe'])
In [493]:
df.str.title()
Out[493]:
swapcase¶
In [494]:
df = pd.Series(['lower', 'CAPITALS', 'this is a sentence', 'SwApCaSe'])
In [495]:
df.str.swapcase()
Out[495]:
Concatenate Two Column in Pandas¶
Method-1¶
In [496]:
df_who['Country_Region']=df_who.Country+'_'+df_who.Region
df_who.head()
Out[496]:
Method-2¶
In [497]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.head()
Out[497]:
In [498]:
df_who['c_r']=df_who['Country'].str.cat(df_who['Region'], sep=',')
df_who.head()
Out[498]:
insert Column in Pandas¶
- More Information
- Insert column into DataFrame at specified location
In [499]:
df_who.insert(2,'Country_Region',df_who.Country+'_'+df_who.Region)
df_who.head()
Out[499]:
In [500]:
df_who.insert(2,'Country_Region',df_who.Country+'_'+df_who.Region,allow_duplicates=True)
df_who.head()
Out[500]:
eval¶
- Evaluate a string describing operations on DataFrame columns.
- Operates on columns only, not specific rows or elements.
- This allows eval to run arbitrary code, which can make you vulnerable to code injection if you pass user input to this function.
- More Information
In [501]:
df = pd.DataFrame({"A":[1, 2],
"B":[3, 4]})
df = df.eval('C=A + B')
df
Out[501]:
assign¶
- Assign new columns to a DataFrame, returning a new object (a copy) with the new columns added to the original ones.
- More Information1
- More Information2
In [502]:
df = pd.DataFrame({
'a': [4, 5, 6, 7],
'b': [10, 20, 30, 40],
'c': [100, 50, -30, -50]
})
df
Out[502]:
In [503]:
df.assign(D=df['a']**2, E=df.b*2)
Out[503]:
query¶
- Query the columns of a frame with a boolean expression.
- More Information
Example-1¶
In [504]:
df = pd.DataFrame()
df['x'] = [11,2,16]
df['y'] = [3,4,15]
In [505]:
df.query('x > y')
Out[505]:
Example-2¶
In [506]:
df1=pd.DataFrame({
'ID':['F2017313014','F2017313015','F2017313017'],
'Marks':[98,97,99],
'Name':['Umer','Ali','Raza']
})
df1
Out[506]:
In [507]:
df2=pd.DataFrame({
'ID':['F2017313014','F2017313018'],
'age':[20,22],
})
df2
Out[507]:
In [508]:
df=pd.merge(df1,df2,on="ID",how="outer",indicator=True)
df
Out[508]:
In [509]:
df=df.query('_merge != "both"')
df
Out[509]:
Drop Columns in Pandas¶
In [510]:
from IPython.display import YouTubeVideo
YouTubeVideo('gnUKkS964WQ',width=900, height=500)
Out[510]:
- More Information
- Drop specified labels from rows or columns
In [511]:
df_who.drop(['Country_Region'],axis=1,inplace=True)
df_who.head()
Out[511]:
In [512]:
df_who.pop('Country')
df_who.head()
Out[512]:
Drop Rows in Pandas¶
In [513]:
df_who= pd.read_csv('WHO_csv.csv')
df_who.drop(df_who.index[[0,2,4]],axis=0,inplace=True)
df_who.head()
Out[513]:
Sort Data Frame¶
In [514]:
from IPython.display import YouTubeVideo
YouTubeVideo('zY4doF6xSxY',width=900, height=500)
Out[514]:
Sort Data Frame w.r.t column¶
- Sort by the values along either axis.
- More Information1
- More Information2
In [515]:
df_who.sort_values('Population')
Out[515]:
In [516]:
df_who.sort_values('Population',ascending=True)
Out[516]:
In [517]:
df_who.sort_values('Population',ascending=False)
Out[517]:
Sort Data Frame w.r.t row¶
In [518]:
df= pd.read_csv('radj.csv',header=0)
df
Out[518]:
In [519]:
pd.DataFrame(np.sort(df.values, axis=1), index=df.index, columns=df.columns)
Out[519]:
Sort by multiple columns¶
In [520]:
df=pd.read_csv("GTRX.txt",skiprows=1,sep=',')
In [521]:
df=df.sort_values(['Cell Name','Is Main BCCH TRX'],ascending=[True,False])
In [522]:
df.to_csv('output8.csv')
argsort¶
In [523]:
df = pd.DataFrame({
'a': [4, 5, 6, 7],
'b': [10, 20, 30, 40],
'c': [100, 50, -30, -50]
})
df
Out[523]:
In [524]:
df.loc[(df.c - 43).abs().argsort()]
Out[524]:
rank¶
- rank method returns a rank of every respective index of a series passed.
- The rank is returned on the basis of position after sorting.
- More Information
In [525]:
df_who["Rank"] = df_who["Population"].rank(ascending=True)
In [526]:
df_who.head()
Out[526]:
In [527]:
df_who.sort_values("Population", inplace = True)
In [528]:
df_who.head()
Out[528]:
Pandas trim leading and trailing white space in a dataframe¶
Example-1¶
In [529]:
df=pd.DataFrame({
'Day':[' 1/1/2019 ',' 1/2/2019 ',' 1/3/2019',' 1/4/2019'],
'Temperature':[30,32,34,36],
'Windspeed':[6,7,10,12],
'Event':[' Rain ',' Su nny ','Rain',' Sunny']
})
df
Out[529]:
In [530]:
df[(df.Event=='Rain')]
Out[530]:
In [531]:
df[(df.Day=='1/3/2019')]
Out[531]:
In [532]:
df =df.applymap(lambda x: x.strip() if isinstance(x, str) else x)
df
Out[532]:
In [533]:
df[(df.Event=='Rain')]
Out[533]:
In [534]:
df[(df.Day=='1/3/2019')]
Out[534]:
Example-2¶
In [535]:
df=' hello world!'
df
Out[535]:
In [536]:
df.lstrip()
Out[536]:
lambda¶
In [537]:
df=pd.read_csv("GTRX.txt",skiprows=1)
In [538]:
def band(Frequency):
if Frequency<100:
return 'GSM'
else:
return 'DCS'
In [539]:
df['Band']=df['Frequency'].apply(lambda x:band(x))
In [540]:
df.head()
Out[540]:
where¶
- More Information1
- More Information2
- Return an object of same shape as self and whose corresponding entries are from self where cond is True and otherwise are from other.
Example-1¶
In [541]:
df=pd.read_csv("GTRX.txt",skiprows=1)
In [542]:
df['Band'] = np.where(
((df['Frequency']>=25) & (df['Frequency']<=62)),
'GSM',
np.where(
(df['Frequency']>=556) & (df['Frequency']<=585),
'DCS',
'Other Band'))
In [543]:
df.head()
Out[543]:
Example-2¶
In [544]:
df=pd.read_csv("GTRX.txt",skiprows=1,sep=',')
In [545]:
df['CI'] = np.where(
(df['Cell Name'].str.startswith ('CI-')),
df['Cell Name'].str[8]+""+df['Cell Name'].str[3:7],
np.where(
(df['Cell Name'].str.startswith ('CII-')),
df['Cell Name'].str[9]+""+df['Cell Name'].str[4:8],
np.where(
(df['Cell Name'].str.startswith ('S-')),
df['Cell Name'].str[7]+""+df['Cell Name'].str[2:5],
np.where(
(df['Cell Name'].str.startswith ('N-')),
df['Cell Name'].str[7]+""+df['Cell Name'].str[2:5],
df['Cell Name'].str[:5]))))
In [546]:
df.head()
Out[546]:
Split a string into multiple columns¶
Method-1¶
In [547]:
spl= pd.read_csv('Scopus_1926-1950.csv',encoding='latin-1')
# Preprocessing
# Remove Space between Author(s)ID
spl['Author(s)ID'] = spl['Author(s)ID'].str.replace(" ","")
# Remove Author(s)ID end with ;
spl['Author(s)ID'] = spl['Author(s)ID'].str.rstrip(';')
- What if we wanted to split the "Author(s)ID" column into Five separate columns, for A0, A1, A2, A3, A4. We would use the str.split() method and tell it to split on a space character and expand the results into a DataFrame
In [548]:
a=spl['Author(s)ID'].str.split(';', expand=True).add_prefix('A')
In [549]:
spl=pd.concat([spl, a], axis=1)
spl.head()
Out[549]:
Method-2¶
In [550]:
spl= pd.read_csv('Scopus_1926-1950.csv',encoding='latin-1')
# Preprocessing
# Remove Space between Author(s)ID
spl['Author(s)ID'] = spl['Author(s)ID'].str.replace(" ","")
# Remove Author(s)ID end with ;
spl['Author(s)ID'] = spl['Author(s)ID'].str.rstrip(';')
- These Five columns can actually be saved to the original DataFrame in a single assignment statement:
In [551]:
spl[['Author0', 'Author1', 'Author2','Author3','Author4']] = spl['Author(s)ID'].str.split(';', expand=True)
In [552]:
spl.head()
Out[552]:
Method-3¶
In [553]:
spl2= pd.read_csv('Scopus_1926-1950.csv',encoding='latin-1')
# Preprocessing
# Remove Space between Author(s)ID
spl2['Author(s)ID'] = spl2['Author(s)ID'].str.replace(" ","")
# Remove Author(s)ID end with ;
spl2['Author(s)ID'] = spl2['Author(s)ID'].str.rstrip(';')
In [554]:
spl2 = spl2.join(spl2['Author(s)ID'].str.split(';', expand=True).add_prefix('Author_'))
In [555]:
spl2.head()
Out[555]:
Special Case¶
- If we only cared about saving the 1st Author ID in column, we can just select that column and save it to the DataFrame:
In [556]:
spl1= pd.read_csv('Scopus_1926-1950.csv',encoding='latin-1')
# Preprocessing
# Remove Space between Author(s)ID
spl1['Author(s)ID'] = spl1['Author(s)ID'].str.replace(" ","")
# Remove Author(s)ID end with ;
spl1['Author(s)ID'] = spl1['Author(s)ID'].str.rstrip(';')
In [557]:
spl1['FAuthor'] = spl1['Author(s)ID'].str.split(';', expand=True)[0]
spl1.head()
Out[557]:
11.22 8 ways to apply LEFT RIGHT MID in Pandas¶
- At times, you may need to extract specific characters within a string.
- You may then apply the concepts of Left, Right, and Mid in pandas to obtain your desired characters within a string.
- the following 8 scenarios to explain how to extract specific characters:
1- From the left¶
In [558]:
Data = pd.DataFrame({'Identifier': ['55555-abc','77777-xyz','99999-mmm']})
Left = Data['Identifier'].str[:5]
Left
Out[558]:
2- From the right¶
In [559]:
Data = pd.DataFrame({'Identifier': ['55555-abc','77777-xyz','99999-mmm']})
Right = Data['Identifier'].str[-3:]
Right
Out[559]:
3- From the middle¶
In [560]:
Data = pd.DataFrame({'Identifier': ['ID-55555-End','ID-77777-End','ID-99999-End']})
Mid = Data['Identifier'].str[3:8]
Mid
Out[560]:
4- Before a symbol¶
In [561]:
Data = pd.DataFrame({'Identifier': ['Umer-55555-H','Ali-77777-A','Ahmed-99999-S']})
BeforeSymbol = Data['Identifier'].str.split('-').str[0]
BeforeSymbol
Out[561]:
5- Before space¶
In [562]:
Data = pd.DataFrame({'Identifier': ['111 IDAA','2222222 IDB','33 IDCCC']})
BeforeSpace = Data['Identifier'].str.split(' ').str[0]
BeforeSpace
Out[562]:
6- After a symbol¶
In [563]:
Data = pd.DataFrame({'Identifier': ['IDAA-111','IDB-2222222','IDCCC-33']})
AfterSymbol = Data['Identifier'].str.split('-').str[1]
AfterSymbol
Out[563]:
7- Between identical symbols¶
In [564]:
Data = pd.DataFrame({'Identifier': ['IDAA-111-AA','IDB-2222222-B','IDCCC-33-CCC']})
BetweenTwoSymbols = Data['Identifier'].str.split('-').str[1]
BetweenTwoSymbols
Out[564]:
8- Between different symbols¶
In [565]:
Data = pd.DataFrame({'Identifier': ['IDAA-111$AA','IDB-2222222$B','IDCCC-33$CCC']})
betweenTwoDifferentSymbols = Data['Identifier'].str.split('-').str[1]
betweenTwoDifferentSymbols = betweenTwoDifferentSymbols.str.split('$').str[0]
betweenTwoDifferentSymbols
Out[565]:
11.23 Missing data handling¶
- Process of cleaning messy data is called data munging or data wranling.
- Fill NaN with specific value
- Fill NaN with Customized Solutions
- Fill NaN with fwd fill method
- Fill NaN with fwd fill method and set Limit
- Fill NaN with backwd method
- Fill NaN with backwd fill method and set Limit
- Fill NaN with fwd fill method on columns
- Fill NaN with fwd fill method on columns with limit
- Fill NaN with bckwd fill method on columns
- Fill NaN with bckwd fill method on columns with limit - Fill NaN using interpolate function
- Drop NaN rows orcolumns
- Drop NaN rows or columns if each element of the row having NaN
- Drop NaN Rows By Appling thresh
In [566]:
from IPython.display import YouTubeVideo
YouTubeVideo('4R4WsDJ-KV',width=900, height=500)
Out[566]:
Example-1¶
In [567]:
df= pd.read_csv("Missing_Values_Handling.csv")
df
Out[567]:
In [568]:
from IPython.display import YouTubeVideo
YouTubeVideo('EaGbS7eWSs0',width=900, height=500)
Out[568]:
Fill NaN with specific value¶
In [569]:
df.fillna(value=0)
Out[569]:
Fill NaN with Customized Solutions¶
In [570]:
df.fillna({
'Temperature':0,
'Windspeed':0,
'Event':'No Event'
})
Out[570]:
Fill NaN with fwd fill method¶
In [571]:
df.fillna(method="ffill")
Out[571]:
Fill NaN with fwd fill method and set Limit¶
In [572]:
df.fillna(method="ffill",limit=1)
Out[572]:
Fill NaN with backwd method¶
In [573]:
df.fillna(method="bfill")
Out[573]:
Fill NaN with backwd fill method and set Limit¶
In [574]:
df.fillna(method="bfill",limit=1)
Out[574]:
Fill NaN with fwd fill method on columns¶
In [575]:
df.fillna(method="ffill",axis="columns")
Out[575]:
Fill NaN with fwd fill method on columns with limit¶
In [576]:
df.fillna(method="ffill",axis="columns",limit=1)
Out[576]:
Fill NaN with bckwd fill method on columns¶
In [577]:
df.fillna(method="bfill",axis="columns")
Out[577]:
Fill NaN with bckwd fill method on columns with limit¶
In [578]:
df.fillna(method="bfill",axis="columns",limit=1)
Out[578]:
Fill NaN using interpolate function¶
In [579]:
df.interpolate()
# This is linear interpolate method
Out[579]:
Drop NaN rows or columns¶
- More Information
- Remove missing values.
In [580]:
df
Out[580]:
In [581]:
df.dropna()
Out[581]:
In [582]:
df.dropna(axis=0)
Out[582]:
In [583]:
df.dropna(axis=1)
Out[583]:
Drop NaN rows or columns if each element of the row having NaN¶
In [584]:
df.set_index('Day',inplace=True)
df.dropna(axis=0,how='all')
Out[584]:
Drop NaN Rows By Appling thresh¶
Example-1¶
In [585]:
df.dropna(thresh=2,axis=0)
Out[585]:
Example-2¶
In [586]:
df.dropna(thresh=len(df)*0.2, axis=0)
Out[586]:
11.24 Replace values methods¶
In [587]:
from IPython.display import YouTubeVideo
YouTubeVideo('XOxABiMhG2U',width=900, height=500)
Out[587]:
In [588]:
df= pd.read_csv("Weather2.csv")
df
Out[588]:
In [589]:
df= pd.read_csv('Weather2.csv',na_values=['Not Available',"n.a"])
df
Out[589]:
Solution-2¶
In [590]:
df= pd.read_csv("Stocks.csv")
df
Out[590]:
In [591]:
df= pd.read_csv("Stocks.csv",na_values=['not available',"n.a","n.a."])
df
Out[591]:
- As we know that Revenue never -ve number
In [592]:
df= pd.read_csv('Stocks.csv',na_values={'EPS':["not available","n.a","n.a."],
'Revenue':["not available","n.a","n.a.",-1],
'Price':["not available","n.a","n.a."],
'People':["not available","n.a","n.a."]
})
df
Out[592]:
In [593]:
df=pd.read_excel("Stocks_ex.xlsx","Stocks")
df
Out[593]:
Example-1¶
In [594]:
def convert_people_cell(cell):
if cell=="n.a.":
return 'Sam Walton'
return cell
In [595]:
df=pd.read_excel("Stocks_ex.xlsx","Stocks",converters={
'People':convert_people_cell
})
df
Out[595]:
Example-2¶
In [596]:
def convert_people_cell(cell):
if cell=="n.a.":
return 'Sam Walton'
return cell
def convert_revenue_cell(cell):
if cell<0:
return 'NaN'
return cell
In [597]:
df=pd.read_excel("Stocks_ex.xlsx","Stocks",converters={
'People':convert_people_cell,
'Revenue':convert_revenue_cell
})
df
Out[597]:
Solution-4¶
Replace¶
Example-1¶
In [598]:
df= pd.read_csv('Replace_DS.csv')
df
Out[598]:
In [599]:
df.replace(-999999,np.NaN)
Out[599]:
Example-2¶
In [600]:
df.replace({
-999999:np.NaN,
'No Event':np.NaN})
Out[600]:
Example-3¶
In [601]:
df= pd.read_csv('Replace_DS1.csv')
df
Out[601]:
In [602]:
df.replace([-999999,-888888,'No Event'],np.NaN)
Out[602]:
Example-4¶
In [603]:
df= pd.read_csv('Replace_DS2.csv')
df
Out[603]:
In [604]:
df.replace({
'Temperature':-999999,
'Windspeed':-888888,
'Event':'0'},np.NaN)
Out[604]:
Example-5¶
In [605]:
df= pd.read_csv('Replace_DS3.csv')
df
Out[605]:
In [606]:
df.replace('[A-Za-z]','',regex=True)
Out[606]:
- Above statment works for Temperature and Windspeed, but not required on Day and Event
In [607]:
df.replace({
'Temperature':'[A-Za-z]',
'Windspeed':'[A-Za-z]'},'',regex=True)
Out[607]:
mask¶
- More Information
- Return an object of same shape as self and whose corresponding entries are from self where cond is False and otherwise are from other.
Example-1¶
In [608]:
df = pd.DataFrame({"A":[12, 4, 5, 44, 1],
"B":[5, 2, 54, 3, 2],
"C":[20, 16, 7, 3, 8],
"D":[14, 3, 17, 2, 6]})
df
Out[608]:
In [609]:
df.mask(df > 10, -25)
Out[609]:
Example-2¶
In [610]:
df = pd.DataFrame({"A":[12, 4, 5, None, 1],
"B":[7, 2, 54, 3, None],
"C":[20, 16, 11, 3, 8],
"D":[14, 3, None, 2, 6]})
df
Out[610]:
In [611]:
df.mask(df.isna(), 1000)
Out[611]:
clip_lower¶
- (DEPRECATED) Return copy of the input with values below a threshold truncated.
- More Information
In [612]:
df=pd.DataFrame({'col_0': [9, -3, 0, -1, 5], 'col_1': [-2, -7, 6, 8, -5]})
df
Out[612]:
In [613]:
df.clip_lower(3)
Out[613]:
clip_upper¶
- (DEPRECATED) Return copy of input with values above given value(s) truncated
- More Information
In [614]:
df=pd.DataFrame({'col_0': [9, -3, 0, -1, 5], 'col_1': [-2, -7, 6, 8, -5]})
df
Out[614]:
In [615]:
df.clip_upper(3)
Out[615]:
clip¶
- Trim values at input threshold(s).
- Assigns values outside boundary to boundary values.
- Thresholds can be singular values or array like, and in the latter case the clipping is performed element-wise in the specified axis.
- More Information
In [616]:
df=pd.DataFrame({'col_0': [9, -3, 0, -1, 5], 'col_1': [-2, -7, 6, 8, -5]})
df
Out[616]:
In [617]:
df.clip(-4, 6)
Out[617]:
combine¶
- Pandas Series.combine() is a series mathematical operation method.
- This is used to combine two series into one. The shape of output series is same as the caller series.
- The elements are decided by a function passed as parameter to combine() method.
- The shape of both series has to be same otherwise it will throw an error
- More Information
Exapmple-1¶
In [618]:
df1 = pd.DataFrame({'A': [0, 2], 'B': [4, 4]})
df1
Out[618]:
In [619]:
df2 = pd.DataFrame({'A': [0, 1], 'B': [8, 8]})
df2
Out[619]:
In [620]:
df1.combine(df2, lambda s1, s2: s1 if s1.sum() < s2.sum() else s2)
Out[620]:
Example-2¶
In [621]:
df1 =pd.Series([1, 2, 5, 6, 3, 7, 11, 0, 4])
df1
Out[621]:
In [622]:
df2 =pd.Series([5, 3, 2, 1, 3, 9, 21, 3, 1])
df2
Out[622]:
In [623]:
df1.combine(df2, (lambda x1, x2: x1 if x1 < x2 else x2))
Out[623]:
combine_first¶
- Two series are created from list using Pandas Series() method.
- Some Null values are also passed to each list using Numpy np.nan.
- Both series are then combined using .combine_first() method.
- At first, the method is called by series1 and result is stored in result1 and then similarly it is called by series2 and stored in result2.
- Both of the returned series are then printed to compare outputs.
- More Information
In [624]:
series1 = pd.Series([70, 5, 0, 225, 1, 16, np.nan, 10, np.nan])
series2 = pd.Series([27, np.nan, 2, 23, 1, 95, 53, 10, 5])
series3 = series1.combine_first(series2)
series3
Out[624]:
In [625]:
series4 = series2.combine_first(series1)
series4
Out[625]:
update¶
- Modify in place using non-NA values from another DataFrame
- More Information
In [626]:
df= pd.DataFrame({'A': ['a', 'b', 'c'],
'B': ['x', 'y', 'z']})
df
Out[626]:
In [627]:
df1 = pd.DataFrame({'B': ['d', 'e', 'f', 'g', 'h', 'i']})
df1
Out[627]:
In [628]:
df.update(df1)
In [629]:
df
Out[629]:
11.25 Varibale types handling¶
Categorical Data¶
In [630]:
df= pd.read_csv('List.csv')
df
Out[630]:
In [631]:
df.sort_values("Score")
Out[631]:
In [632]:
from pandas.api.types import CategoricalDtype
df['Score'] = df['Score'].astype(CategoricalDtype(categories=['Poor','Good','V Good','Exceptional'],ordered=True))
df
Out[632]:
In [633]:
df.sort_values("Score")
Out[633]:
In [634]:
df.loc[df.Score >= 'Good']
Out[634]:
get_dummies¶
- If we wanted to separate the distinct variables out into booleans as we would like for data science models such as for example, linear regression, we can use pd.get_dummies.
In [635]:
from IPython.display import YouTubeVideo
YouTubeVideo('0s_1IsROgDc',width=900, height=500)
Out[635]:
In [636]:
pd.get_dummies(df, columns=['Score'])
Out[636]:
Nominal Categories¶
In [637]:
df= pd.read_csv('Gender.csv')
df
Out[637]:
In [638]:
df['Sex']=df.Gender.astype("category").cat.codes
df
Out[638]:
map¶
In [639]:
df= pd.read_csv('Gender.csv')
df
Out[639]:
In [640]:
df['Sex_num'] = df.Gender.map({'Female':0, 'Male':1})
df
Out[640]:
Example¶
In [641]:
df_who= pd.read_csv('WHO_csv.csv')
In [642]:
df_who.memory_usage()
Out[642]:
In [643]:
df_who= pd.read_csv('WHO_csv.csv',dtype = {"Region" : "category"})
In [644]:
df_who.dtypes
Out[644]:
In [645]:
df_who.memory_usage()
Out[645]:
Example¶
In [646]:
df_who= pd.read_csv('WHO_csv.csv',dtype = {"Region" : "category",'Country':'category'})
In [647]:
df_who.dtypes
Out[647]:
In [648]:
df_who.memory_usage()
Out[648]:
Convert continuous data into categorical data¶
In [649]:
df= pd.read_csv('titanic.csv')
df.head()
Out[649]:
- It's currently continuous data, but what if you wanted to convert it into categorical data.
- One solution would be to label the age ranges, such as "child", "young adult", and "adult". The best way to do this is by using the cut() function:
In [650]:
df['cage']=pd.cut(df.Age, bins=[0, 18, 25, 99], labels=['child', 'young adult', 'adult'])
In [651]:
df.head()
Out[651]:
In [652]:
df.tail()
Out[652]:
In [653]:
df['cage'].dtypes
Out[653]:
- This assigned each value to a bin with a label.
- Ages 0 to 18 were assigned the label "child",
- ages 18 to 25 were assigned the label "young adult",
- and ages 25 to 99 were assigned the label "adult".
- Notice that the data type is now "category", and the categories are automatically ordered.
qcut¶
- More Information
- Quantile-based discretization function.
- Discretize variable into equal-sized buckets based on rank or based on sample quantiles.
- For example 1000 values for 10 quantiles would produce a Categorical object indicating quantile membership for each data point.
In [654]:
df= pd.qcut(range(5), 4)
df
Out[654]:
In [655]:
df=pd.qcut(range(5), 3, labels=["good", "medium", "bad"])
df
Out[655]:
In [656]:
df=pd.qcut(range(5), 4, labels=False)
df
Out[656]:
11.26 CONCATENATE¶
In [657]:
from IPython.display import YouTubeVideo
YouTubeVideo('WGOEFok1szA',width=900, height=500)
Out[657]:
CONCATENATE w.r.t. rows¶
In [658]:
df1= pd.read_csv('KPK_Weather.csv')
df1
Out[658]:
In [659]:
df2= pd.read_csv('Punjab_Weather.csv')
df2
Out[659]:
In [660]:
df=pd.concat([df1,df2])
df
Out[660]:
Solution for Index¶
In [661]:
df=pd.concat([df1,df2],ignore_index=True)
df
Out[661]:
keys¶
In [662]:
df=pd.concat([df1,df2],keys=['KPK','Punjab'])
df
Out[662]:
In [663]:
df.loc['Punjab']
Out[663]:
In [664]:
df.loc['KPK']
Out[664]:
CONCATENATE w.r.t col¶
Exammple-1¶
In [665]:
df1= pd.read_csv('WTemData.csv')
df1
Out[665]:
In [666]:
df2= pd.read_csv('WWSData.csv')
df2
Out[666]:
In [667]:
df=pd.concat([df1,df2])
df
Out[667]:
Solution¶
In [668]:
df=pd.concat([df1,df2],axis=1)
df
Out[668]:
Example-2¶
In [669]:
df1=pd.DataFrame({
'City':['LHR','SHD','GJW','SKT'],
'temperature':[30,32,34,36]})
df1
Out[669]:
In [670]:
df2=pd.DataFrame({
'City':['SKT','GJW','SHD','LHR'],
'windspeed':[7,8,9,10]})
df2
Out[670]:
In [671]:
df=pd.concat([df1,df2],axis=1)
df
Out[671]:
Solution¶
In [672]:
df1=pd.DataFrame({
'City':['LHR','SHD','GJW','SKT'],
'temperature':[30,32,34,36]},index=[0,1,2,3])
df1
Out[672]:
In [673]:
df2=pd.DataFrame({
'City':['SKT','GJW','SHD','LHR'],
'windspeed':[7,8,9,10]},index=[3,2,1,0])
df2
Out[673]:
In [674]:
df=pd.concat([df1,df2],axis=1)
df
Out[674]:
11.27 Merge Dataframes¶
In [675]:
from IPython.display import YouTubeVideo
YouTubeVideo('h4hOPGo4UVU',width=900, height=500)
Out[675]:
Inner Join¶
- Join columns with other DataFrame either on index or on a key column.
- Efficiently Join multiple DataFrame objects by index at once by passing a list.
- More Information1
- More Information2
Example-1¶
In [676]:
df1=pd.DataFrame({
'City':['LHR','SHD','GJW','SKT'],
'temperature':[30,32,34,36]})
df1
Out[676]:
In [677]:
df2=pd.DataFrame({
'City':['SKT','GJW','SHD','LHR'],
'windspeed':[7,8,9,10]})
df2
Out[677]:
In [678]:
df=pd.merge(df1,df2,on="City")
df
Out[678]:
Example-2¶
In [679]:
df1= pd.read_csv('Family.csv',skipfooter=1,engine='python')
df1
Out[679]:
In [680]:
df2= pd.read_csv('Math.txt',sep=",")
df2
Out[680]:
In [681]:
df=pd.merge(df1,df2,on="ID")
df
Out[681]:
Example-3¶
In [682]:
df1= pd.read_csv('ListStu.txt',sep=",")
df1
Out[682]:
In [683]:
df2= pd.read_csv('Listage.txt',sep=",")
df2
Out[683]:
In [684]:
df=pd.merge(df1,df2,on="ID")
df
Out[684]:
Example-4¶
In [685]:
df=pd.merge(df1,df2,on="ID",how="inner")
df
Out[685]:
Outer Join¶
In [686]:
df1= pd.read_csv('ListStu.txt',sep=",")
df1
Out[686]:
In [687]:
df2= pd.read_csv('Listage.txt',sep=",")
df2
Out[687]:
In [688]:
df=pd.merge(df1,df2,on="ID",how="outer")
df
Out[688]:
Left Join¶
In [689]:
df1= pd.read_csv('ListStu.txt',sep=",")
df1
Out[689]:
In [690]:
df2= pd.read_csv('Listage.txt',sep=",")
df2
Out[690]:
In [691]:
df=pd.merge(df1,df2,on="ID",how="left")
df
Out[691]:
Right Join¶
In [ ]:
In [692]:
df1= pd.read_csv('ListStu.txt',sep=",")
df1
Out[692]:
In [693]:
df2= pd.read_csv('Listage.txt',sep=",")
df2
Out[693]:
In [694]:
df=pd.merge(df1,df2,on="ID",how="right")
df
Out[694]:
Indicator¶
In [695]:
import pandas as pd
df1= pd.read_csv('ListStu.txt',sep=",")
df1
Out[695]:
In [696]:
df2= pd.read_csv('Listage.txt',sep=",")
df2
Out[696]:
In [697]:
df=pd.merge(df1,df2,on="ID",how="outer",indicator=True)
df
Out[697]:
Suffixes¶
Example-1¶
In [698]:
df1=pd.DataFrame({
'ID':['F2017313014','F2017313015'],
'Marks':[98,97]
})
df1
Out[698]:
In [699]:
df2=pd.DataFrame({
'ID':['F2017313014','F2017313015'],
'Marks':[96,95]
})
df2
Out[699]:
In [700]:
df=pd.merge(df1,df2,on="ID")
df
Out[700]:
Exaample-2¶
In [701]:
df1=pd.DataFrame({
'ID':['F2017313014','F2017313015'],
'Marks':[98,97]
})
df1
Out[701]:
In [702]:
df2=pd.DataFrame({
'ID':['F2017313014','F2017313015'],
'Marks':[96,95]
})
df2
Out[702]:
In [703]:
df=pd.merge(df1,df2,on="ID",suffixes=('_Math','_Physics'))
df
Out[703]:
Example-3¶
In [704]:
df1=pd.DataFrame({
'ID':['F2017313014','F2017313015'],
'Marks':[98,97],
'Name':['Umer','Ali']
})
df1
Out[704]:
In [705]:
df2=pd.DataFrame({
'ID':['F2017313014','F2017313015'],
'Marks':[96,95],
'Name':['Amir','Yaqoob']
})
df2
Out[705]:
In [706]:
df=pd.merge(df1,df2,on="ID",suffixes=('_left','_right'))
df
Out[706]:
merge_ordered¶
- Perform merge with optional filling/interpolation designed for ordered data like time series data.
- Optionally perform group-wise merge (see examples)
In [707]:
df1 = pd.DataFrame({'key': list('aceace'), 'group': list('aaabbb'), 'lvalue': [1, 2, 3, 1, 2, 3]})[[ 'group','key', 'lvalue']]
df1
Out[707]:
In [708]:
df2 = pd.DataFrame({'key': list('bcd'), 'rvalue': [1, 2, 3]})[[ 'rvalue','key']]
df2
Out[708]:
In [709]:
pd.merge_ordered(df1, df2, left_by='group')
Out[709]:
In [710]:
pd.merge_ordered(df1, df2, left_by='group',fill_method='ffill')
Out[710]:
merge_asof¶
- Perform an asof merge. This is similar to a left-join except that we match on nearest key rather than equal keys.
- Both DataFrames must be sorted by the key
- More Information
In [711]:
df1 = pd.DataFrame({'a': [1, 5, 10], 'left_val': ['a', 'b', 'c']})
df1
Out[711]:
In [712]:
df2 = pd.DataFrame({'a': [1, 2, 3, 6, 7],
'right_val': [1, 2, 3, 6, 7]})
df2
Out[712]:
In [713]:
pd.merge_asof(df1, df2, on='a')
Out[713]:
In [714]:
pd.merge_asof(df1, df2, on='a', allow_exact_matches=True)
Out[714]:
In [715]:
pd.merge_asof(df1, df2, on='a', allow_exact_matches=False)
Out[715]:
lookup¶
In [716]:
df1 = pd.DataFrame([[1,2,3,4], [6,7,8,9]], columns=['D', 'B', 'E', 'A'])
df1
Out[716]:
In [717]:
df2 = pd.DataFrame([[10,20,30,40], [60,70,80,90], [600,700,800,900]], columns=['A', 'B', 'C', 'D'])
df2
Out[717]:
In [718]:
a1,a2=df1.align(df2, join='inner', axis=1)
In [719]:
a1
Out[719]:
In [720]:
a2
Out[720]:
append¶
- More Information
- Append rows of other to the end of this frame, returning a new object.
In [721]:
a1.append(a2)
Out[721]:
In [722]:
a1.append(a2,ignore_index=True)
Out[722]:
Add column to pandas dataframe with partial file name while importing many files¶
In [723]:
import os
#import glob
from glob import glob
#all_files = glob.glob('Scopus*.csv')
all_files = glob('Scopus*.csv')
df_from_each_file = (pd.read_csv(f,encoding='latin-1').assign(fname=os.path.basename(f).split('.')[0]) for f in all_files)
concatdf = pd.concat(df_from_each_file, ignore_index=True)
concatdf[['Title','fname']].head()
Out[723]:
Build a DataFrame from multiple files¶
w.r.t rows¶
In [724]:
scopus_files = sorted(glob('Scopus*.csv'))
scopus_files
Out[724]:
- glob returns filenames in an arbitrary order, which is why we sorted the list using Python's built-in sorted() function.
- We can then use a generator expression to read each of the files using read_csv() and pass the results to the concat() function, which will concatenate the rows into a single DataFrame:
In [725]:
pd.concat((pd.read_csv(file,encoding='latin-1') for file in scopus_files))
Out[725]:
- Unfortunately, there are now duplicate values in the index. To avoid that, we can tell the concat() function to ignore the index and instead use the default integer index:
In [726]:
pd.concat((pd.read_csv(file,encoding='latin-1') for file in scopus_files), ignore_index=True)
Out[726]:
w.r.t column¶
In [727]:
student_files = sorted(glob('Student*.csv'))
student_files
Out[727]:
In [728]:
pd.concat((pd.read_csv(file) for file in student_files), axis='columns')
Out[728]:
11.28 Pivot¶
In [729]:
from IPython.display import YouTubeVideo
YouTubeVideo('xPPs59pn6qU',width=900, height=500)
Out[729]:
- More Information
- pivot allows us to transform or reshape data
In [730]:
df= pd.read_csv('Weather3.csv')
df
Out[730]:
In [731]:
df.pivot(index="Date",columns="City")
Out[731]:
- if only Temperature values required.
In [732]:
df.pivot(index="Date",columns="City",values='Temperature')
Out[732]:
11.29 Pivot Table¶
- More Information
- Pivot table is used to summarize and aggregate data inside dataframe
In [733]:
df= pd.read_csv('Weather4.csv')
df
Out[733]:
Example-1¶
In [734]:
df.pivot_table(index="City",columns="Date")
Out[734]:
Example-2¶
In [735]:
df.pivot_table(index="City",columns="Date",values='Temperature')
Out[735]:
Example-3¶
In [736]:
df.pivot_table(index="City",columns="Date",values='Temperature',aggfunc='sum')
Out[736]:
Example-4¶
In [737]:
df.pivot_table(index="City",columns="Date",values='Temperature',aggfunc='count')
Out[737]:
Example-5¶
In [738]:
df.pivot_table(index="City",columns="Date",values='Temperature',aggfunc='mean')
Out[738]:
Example-6¶
In [739]:
df.pivot_table(index="City",columns="Date",values='Temperature',margins=True,aggfunc='sum')
Out[739]:
Example-7¶
In [740]:
df.pivot_table(index="City",columns="Date",values='Temperature',margins=True)
Out[740]:
11.30 Grouper¶
Example-1¶
In [741]:
df= pd.read_csv('Weather5.csv',parse_dates=['Date'])
df
Out[741]:
In [742]:
df.pivot_table(index=pd.Grouper(freq='M',key='Date'),columns='City')
Out[742]:
Example-2¶
In [743]:
df.pivot_table(index=pd.Grouper(freq='M',key='Date'),columns='City',aggfunc='sum')
Out[743]:
11.31 Melt¶
- Melt is used to transform or reshape data
- “Unpivots” a DataFrame from wide format to long format, optionally leaving identifier variables set.
- This function is useful to massage a DataFrame into a format where one or more columns are identifier variables (id_vars), while all other columns, considered measured variables (value_vars), are “unpivoted” to the row axis, leaving just two non-identifier columns, ‘variable’ and ‘value’.
- More Information
In [744]:
from IPython.display import YouTubeVideo
YouTubeVideo('oY62o-tBHF4',width=900, height=500)
Out[744]:
In [745]:
df= pd.read_csv('Weather6.csv')
df
Out[745]:
Example-1¶
In [746]:
df1=pd.melt(df,id_vars=["Day"])
df1
Out[746]:
Example-2¶
In [747]:
df1=pd.melt(df,id_vars=["Day"],var_name="City", value_name='Temp')
df1
Out[747]:
Example-3¶
In [748]:
df1[df1["City"]=="Lahore"]
Out[748]:
11.32 Crosstab¶
In [749]:
from IPython.display import YouTubeVideo
YouTubeVideo('I_kUj-MfYys',width=900, height=500)
Out[749]:
In [750]:
df=pd.read_csv("Handedness.csv")
df
Out[750]:
Example-1¶
In [751]:
pd.crosstab(df.Nationality,df.Handedness)
Out[751]:
Example-2¶
In [752]:
pd.crosstab(df.Sex,df.Handedness)
Out[752]:
Example-3¶
In [753]:
pd.crosstab(df.Sex,df.Handedness,margins=True)
Out[753]:
Example-4¶
In [754]:
pd.crosstab(df.Sex,df.Handedness,margins=True,values=df.Age,aggfunc='mean')
Out[754]:
Example-5¶
In [755]:
pd.crosstab(df.Sex,df.Handedness,normalize='index')
Out[755]:
Example-6¶
In [756]:
pd.crosstab(df.Sex,[df.Handedness,df.Nationality],margins=True)
Out[756]:
Example-7¶
In [757]:
pd.crosstab([df.Sex,df.Nationality],df.Handedness,margins=True)
Out[757]:
11.33 groupby¶
In [758]:
from IPython.display import YouTubeVideo
YouTubeVideo('qy0fDqoMJx8',width=900, height=500)
Out[758]:
- More Information 1
- More Information 2
- Group series using mapper (dict or key function, apply given function to group, return result as series) or by a series of columns.
In [759]:
df= pd.read_csv('GroupBy.csv')
df
Out[759]:
Example-1¶
In [760]:
df.groupby('City').Temperature.sum()
Out[760]:
Example-2¶
In [761]:
df.groupby(['Province', 'City']).Temperature.sum()
Out[761]:
Example-3¶
In [762]:
df.groupby(['Province', 'City']).Temperature.sum().unstack()
Out[762]:
11.34 get_group¶
In [763]:
df= pd.read_csv('GroupBy.csv')
df1=df.groupby('City')
df2=df1.get_group('Lahore')
df2
Out[763]:
In [764]:
df2.mean()
Out[764]:
In [765]:
df2.describe()
Out[765]:
11.35 Transform Function in Pandas¶
- Call function producing a like-indexed NDFrame and return a NDFrame with the transformed values
- More Information
Example-1¶
In [766]:
df = pd.read_csv('chipotle.tsv',sep='\t')
df.head()
Out[766]:
In [767]:
df.dtypes
Out[767]:
In [768]:
# Preprocessing (Step-1)
df['item_price'] = df['item_price'].str.replace("$","")
In [769]:
df.dtypes
Out[769]:
In [770]:
# Preprocessing (Step-2)
df['item_price'] = pd.to_numeric(df['item_price'])
In [771]:
df.dtypes
Out[771]:
- Each order has an order_id and consists of one or more rows. To figure out the total price of an order, you sum the item_price for that order_id. For example, here's the total price of order number 1:
In [772]:
df[df.order_id == 1].item_price.sum()
Out[772]:
- If you wanted to calculate the total price of every order, you would groupby() order_id and then take the sum of item_price for each group:
In [773]:
df.groupby('order_id').item_price.sum().head()
Out[773]:
- However, you're not actually limited to aggregating by a single function such as sum().
- To aggregate by multiple functions, you use the agg() method and pass it a list of functions such as sum() and count():
In [774]:
df.groupby('order_id').item_price.agg(['sum', 'count']).head()
Out[774]:
In [775]:
len(df.groupby('order_id').item_price.sum())
Out[775]:
...is smaller than the input to the function:
In [776]:
len(df.item_price)
Out[776]:
- The solution is to use the transform() method, which performs the same calculation but returns output data that is the same shape as the input data:
In [777]:
df['total_price'] = df.groupby('order_id').item_price.transform('sum')
In [778]:
df.head()
Out[778]:
- As you can see, the total price of each order is now listed on every single line.
- That makes it easy to calculate the percentage of the total order price that each line represents:
In [779]:
df['percent_of_total'] = df.item_price / df.total_price
Example-2¶
In [780]:
df = pd.DataFrame({"measure": ["a","a","b","a","c","c"],
"aq": [10,20,30,20,30,50]})
df
Out[780]:
In [781]:
df["colour"] = (100.0 * df["aq"] /
df.groupby("measure")["aq"].transform(max))
df
Out[781]:
11.36 Remove duplicate rows in pandas¶
- More Information
- Return DataFrame with duplicate rows removed, optionally only considering certain columns
In [782]:
from IPython.display import YouTubeVideo
YouTubeVideo('ht5buXUMqkQ',width=900, height=500)
Out[782]:
In [783]:
df= pd.read_csv('DupDS.csv')
df
Out[783]:
identify duplicated rows¶
- More Information
- Return boolean Series denoting duplicate rows, optionally only considering certain columns
In [784]:
df.duplicated()
Out[784]:
In [785]:
df.duplicated().sum()
Out[785]:
Find duplicated rows¶
In [786]:
df.loc[df.duplicated(),:]
Out[786]:
In [787]:
df.loc[df.duplicated(keep='first'),:]
Out[787]:
In [788]:
df.loc[df.duplicated(keep='last'),:]
Out[788]:
In [789]:
df.loc[df.duplicated(keep=False),:]
Out[789]:
Shape of the Data Frame after drop duplicates¶
In [790]:
df.drop_duplicates().shape
Out[790]:
In [791]:
df.drop_duplicates(keep='first').shape
Out[791]:
In [792]:
df.drop_duplicates(keep='last').shape
Out[792]:
In [793]:
df.drop_duplicates(keep=False).shape
Out[793]:
Data Frame after drop duplicates¶
In [794]:
df.drop_duplicates()
Out[794]:
In [795]:
df.drop_duplicates(keep='first')
Out[795]:
In [796]:
df.drop_duplicates(keep='last')
Out[796]:
In [797]:
df.drop_duplicates(keep=False)
Out[797]:
11.37 Pandas Stack¶
In [798]:
from IPython.display import YouTubeVideo
YouTubeVideo('BUOy4RUUepg',width=900, height=500)
Out[798]:
- Stack the prescribed level(s) from columns to index.
- More Information
Example-1¶
In [799]:
df=pd.read_excel("Company.xlsx",header=[0,1],index_col=[0])
df
Out[799]:
In [800]:
df1=df.stack()
df1
Out[800]:
In [801]:
df2=df.stack(level=0)
df2
Out[801]:
11.38 Pandas Unstack¶
- More Information
- Pivot a level of the (necessarily hierarchical) index labels, returning a DataFrame having a new level of column labels whose inner-most level consists of the pivoted index labels.
In [802]:
df2.unstack()
Out[802]:
Example-2¶
In [803]:
df=pd.read_excel("Company1.xlsx",header=[0,1,2],index_col=[0])
df
Out[803]:
In [804]:
df1=df.stack()
df1
Out[804]:
In [805]:
df2=df.stack(level=0)
df2
Out[805]:
In [806]:
df3=df.stack(level=1)
df3
Out[806]:
In [807]:
df4=df.stack(level=2)
df4
Out[807]:
- by defalult level is most inner one.
11.39 Python Pandas replicate rows in dataframe¶
Example-1¶
In [808]:
df=pd.read_csv("rep.csv")
df
Out[808]:
In [809]:
pd.concat([df]*3)
Out[809]:
In [810]:
pd.concat([df]*3, ignore_index=True)
Out[810]:
Example-2¶
In [811]:
rep2 = df.loc[np.repeat(df.index.values,df.Rep)].reset_index(drop=True)
rep2
Out[811]:
In [812]:
rep2 = rep2.drop("Rep",axis=1).reset_index(drop=True)
rep2
Out[812]:
11.40 Data manipulations¶
Conditional rolling count¶
In [813]:
df= pd.read_csv('maybe.csv',header=0)
df
Out[813]:
In [814]:
df['count'] = df.groupby('Year').cumcount() + 0
df
Out[814]:
compound¶
- Return the compound percentage of the values for the requested axis
- More Information1
- More Information2
- So for columns a: [(0+1)(2+1)(4+1)]-1=[(1)(3)(5)]-1=15-1=14
- So for columns b: [(1+1)(3+1)(5+1)]-1=[(2)(4)(6)]-1=48-1=47
In [815]:
df = pd.DataFrame(np.arange(6).reshape(3,2), columns=['a', 'b'])
df
Out[815]:
In [816]:
df.compound()
Out[816]:
cumprod¶
- Return cumulative product over a DataFrame or Series axis
- More Information
In [817]:
df = pd.Series([2, 10, np.nan, 4, 3, 0, 1])
df.cumprod()
Out[817]:
cummax¶
- Return cumulative maximum over a DataFrame or Series axis.
- Returns a DataFrame or Series of the same size containing the cumulative maximum
- More Information
Example-1¶
In [818]:
df = pd.Series([2, np.nan, 5, -1, 0])
df
Out[818]:
- By default, NA values are ignored.
In [819]:
df.cummax()
Out[819]:
- To include NA values in the operation, use skipna=False
In [820]:
df.cummax(skipna=False)
Out[820]:
Example-2¶
In [821]:
df = pd.DataFrame([[2.0, 1.0],
[3.0, np.nan],
[1.0, 0.0]],
columns=list('AB'))
df
Out[821]:
- By default, iterates over rows and finds the maximum in each column. This is equivalent to axis=None or axis='index'
In [822]:
df.cummax()
Out[822]:
- To iterate over columns and find the maximum in each row, use axis=1
In [823]:
df.cummax(axis=1)
Out[823]:
cummin¶
- Return cumulative minimum over a DataFrame or Series axis.
- Returns a DataFrame or Series of the same size containing the cumulative minimum.
- More Information
Example-1¶
In [824]:
df = pd.Series([2, np.nan, 5, -1, 0])
df
Out[824]:
- By default, NA values are ignored.
In [825]:
df.cummin()
Out[825]:
- To include NA values in the operation, use skipna=False
In [826]:
df.cummin(skipna=False)
Out[826]:
Example-2¶
In [827]:
df = pd.DataFrame([[2.0, 1.0],
[3.0, np.nan],
[1.0, 0.0]],
columns=list('AB'))
- By default, iterates over rows and finds the maximum in each column. This is equivalent to axis=None or axis='index'
In [828]:
df.cummin()
Out[828]:
- To iterate over columns and find the maximum in each row, use axis=1.
In [829]:
df.cummin(axis=1)
Out[829]:
cumsum¶
- Return cumulative sum over a DataFrame or Series axis.
- Returns a DataFrame or Series of the same size containing the cumulative sum.
- More Information
Example-1¶
In [830]:
df = pd.Series([2, np.nan, 5, -1, 0])
df
Out[830]:
- By default, NA values are ignored.
In [831]:
df.cumsum()
Out[831]:
- To include NA values in the operation, use skipna=False
In [832]:
df.cumsum(skipna=False)
Out[832]:
Example-2¶
In [833]:
df = pd.DataFrame([[2.0, 1.0],
[3.0, np.nan],
[1.0, 0.0]],
columns=list('AB'))
df
Out[833]:
- By default, iterates over rows and finds the sum in each column. This is equivalent to axis=None or axis='index'.
In [834]:
df.cumsum()
Out[834]:
- To iterate over columns and find the sum in each row, use axis=1
In [835]:
df.cumsum(axis=1)
Out[835]:
Example-3¶
In [836]:
df= pd.read_csv('maybe.csv',header=0)
df
Out[836]:
In [837]:
df.iat[2, 1]=1983
In [838]:
df
Out[838]:
In [839]:
df['GD'] = (df['Year'] != df['Year'].shift(1)).astype(int).cumsum()
In [840]:
df['count'] = df.groupby('GD').cumcount() + 0
df
Out[840]:
expanding¶
- Provides expanding transformations.
- More Information
In [841]:
df = pd.DataFrame({'B': [0, 3, 2, 7, 4]})
df
Out[841]:
In [842]:
df.expanding(2).sum()
Out[842]:
rolling¶
- Provide rolling window calculations.
- More Information
In [843]:
df = pd.DataFrame({'B': [0, 3, 2, 7, 4]})
df
Out[843]:
In [844]:
df.rolling(2).sum()
Out[844]:
pct_change¶
- More Information
- Percentage change between the current and a prior element.
- Computes the percentage change from the immediately previous row by default.
- This is useful in comparing the percentage of change in a time series of elements.
In [845]:
df= pd.read_csv('AAPL.csv',parse_dates=['Date'])
df
Out[845]:
In [846]:
df['dchange']=100*df['Close'].pct_change()
df
Out[846]:
11.41 Data Frame Formatting in Pandas¶
In [847]:
from IPython.display import YouTubeVideo
YouTubeVideo('yiO43TQ4xvc',width=900, height=500)
Out[847]:
Display Rows Method in Pandas¶
In [848]:
df_who= pd.read_csv('WHO_csv.csv')
pd.get_option('display.max_rows')
Out[848]:
Example-1¶
In [849]:
df_who= pd.read_csv('WHO_csv.csv')
pd.set_option('display.max_rows',None)
df_who
Out[849]:
Example-2¶
In [850]:
pd.reset_option('all',silent=True)
import pandas as pd
df_who= pd.read_csv('WHO_csv.csv')
pd.set_option('display.max_rows',6)
df_who
Out[850]:
reset_option¶
In [851]:
pd.reset_option('display.max_rows')
df_who
#Method-2
#pd.reset_option('all',silent=True)
Out[851]:
colwidth¶
In [852]:
pd.reset_option('all',silent=True)
df_who= pd.read_csv('WHO_csv.csv')
pd.set_option('display.max_colwidth',10)
df_who.head()
Out[852]:
Display Precision¶
In [853]:
pd.reset_option('all',silent=True)
df_who= pd.read_csv('WHO_csv.csv')
pd.set_option('display.precision',1)
df_who.head()
Out[853]:
Display , in Float¶
In [854]:
pd.reset_option('all',silent=True)
df_who= pd.read_csv('WHO_csv.csv')
pd.set_option('display.float_format','{:,}'.format)
df_who.head()
Out[854]:
Style a DataFrame¶
- The previous trick is useful if you want to change the display of your entire notebook. However, a more flexible and powerful approach is to define the style of a particular DataFrame.
- Let's return to the stocks DataFrame:
In [855]:
df= pd.read_csv('Sale.txt',sep=",",parse_dates=['Date'])
df
Out[855]:
- We can create a dictionary of format strings that specifies how each column should be formatted
- And then we can pass it to the DataFrame's style.format() method:
In [856]:
df.style.format({'Symbol': str.lower,'Volume':'{:,}','Date':'{:%m/%d/%y}','Close':'${:.2f}'})
Out[856]:
- Notice that the Date is now in month-day-year format, the closing price has a dollar sign, and the Volume has commas.
- We can apply more styling by chaining additional methods
In [857]:
(df.style.format({'Symbol': str.lower,'Volume':'{:,}','Date':'{:%m/%d/%y}','Close':'${:.2f}'})
.hide_index()
.highlight_min(['Close','Volume'], color='red')
.highlight_max('Close', color='lightgreen')
)
Out[857]:
- We've now hidden the index, highlighted the minimum Close value in red, and highlighted the maximum Close value in green.
- Here's another example of DataFrame styling:
In [858]:
(df.style.format({'Symbol': str.lower,'Volume':'{:,}','Date':'{:%m/%d/%y}','Close':'${:.2f}'})
.hide_index()
.background_gradient(subset='Volume', cmap='Blues')
)
Out[858]:
- The Volume column now has a background gradient to help you easily identify high and low values.
- And here's one final example
In [859]:
(df.style.format({'Symbol': str.lower,'Volume':'{:,}','Date':'{:%m/%d/%y}','Close':'${:.2f}'})
.hide_index()
.bar('Volume', color='lightblue', align='zero')
.set_caption('Stock Prices from October 2016')
)
Out[859]:
- There's now a bar chart within the Volume column and a caption above the DataFrame.
- Note that there are many more options for how you can style your DataFrame
- More Information
11.42 Time Series Analysis¶
- Timeseries is a set of data points indexed in time order.
In [860]:
from IPython.display import YouTubeVideo
YouTubeVideo('yCgJGsg0Xa4',width=900, height=500)
Out[860]:
Data Type of Date¶
In [861]:
from IPython.display import YouTubeVideo
YouTubeVideo('r0s4slGHwzE',width=900, height=500)
Out[861]:
In [862]:
df= pd.read_csv('AAPL.csv')
In [863]:
df.head()
Out[863]:
In [864]:
type(df.Date[0])
Out[864]:
Solution¶
In [865]:
df= pd.read_csv('AAPL.csv',parse_dates=['Date'])
In [866]:
df.head()
Out[866]:
In [867]:
type(df.Date[0])
Out[867]:
Select Date Col to Index¶
In [868]:
df= pd.read_csv('AAPL.csv',parse_dates=['Date'],index_col='Date')
df.head()
Out[868]:
In [869]:
df.index
Out[869]:
partial index¶
Example-1¶
In [870]:
df['2018-01']
Out[870]:
Example-2¶
- Find Mean Price of Apple's Stock in Jan,2018
In [871]:
df['2018-01'].Close.mean()
Out[871]:
Example-3¶
In [872]:
df.loc['2018-01-29']
Out[872]:
Example-4¶
In [873]:
df['2018-01-15':'2018-01-20']
Out[873]:
Example-5¶
In [874]:
df['2018-01-15':'2018-01-20'].mean()
Out[874]:
Example-6¶
In [875]:
df['2018-01-15':'2018-01-20'].Close.mean()
Out[875]:
Resampling¶
- Convenience method for frequency conversion and resampling of time series.
- More Information
Example-1¶
- Find Monthly Average Price of Apple's Stock in 2018
- More Information
In [876]:
df.resample('M').mean()
Out[876]:
Example-2¶
In [877]:
df['Close'].resample('M').mean()
Out[877]:
Date Range¶
In [878]:
from IPython.display import YouTubeVideo
YouTubeVideo('A9c7hGXQ5A8',width=900, height=500)
Out[878]:
Example-1¶
In [879]:
df= pd.read_csv('AAPLwd.csv')
df.head()
Out[879]:
- Date column is missing in the data set
In [880]:
df1= pd.date_range(start="1/2/2018", end="1/31/2018",freq='B')
df1
Out[880]:
In [881]:
df.set_index(df1,inplace=True)
df
Out[881]:
Example-2¶
- Include wk end in the data set
- method='pad' : Fwd fill method (get the values for 'Sat' and 'Sun' from 'Fri')
In [882]:
df.asfreq('D',method='pad')
Out[882]:
Example-3¶
In [883]:
df.asfreq('W',method='pad')
Out[883]:
Example-4¶
In [884]:
df.asfreq('H',method='pad')
Out[884]:
Example-5¶
In [885]:
df= pd.date_range(start='1/1/2017',periods=72, freq='B')
df
Out[885]:
In [886]:
ts=pd.Series(np.random.randint(1,10,len(df)),index=df)
ts
Out[886]:
bdate_range¶
- Return a fixed frequency DatetimeIndex, with business day as the default frequency
- More Information
In [887]:
bd=pd.bdate_range(start='9/1/2019', end='9/16/2019')
bd
Out[887]:
timedelta_range¶
- Return a fixed frequency TimedeltaIndex, with day as the default frequency
- More Information
In [888]:
tr=pd.timedelta_range(start='1 day', periods=4)
tr
Out[888]:
In [889]:
tr=pd.timedelta_range(start='1 day', periods=4,closed='right')
tr
Out[889]:
In [890]:
tr=pd.timedelta_range(start='1 day', periods=4,closed='left')
tr
Out[890]:
In [891]:
tr=pd.timedelta_range(start='1 day', end='2 days', freq='6H')
tr
Out[891]:
interval_range¶
- Return a fixed frequency IntervalIndex
- More Information
In [892]:
ir=pd.interval_range(start=0, end=5)
ir
Out[892]:
In [893]:
ir= pd.interval_range(start=pd.Timestamp('2017-01-01'),
end=pd.Timestamp('2017-01-04'))
ir
Out[893]:
In [894]:
ir=pd.interval_range(start=0, periods=4, freq=1.5)
ir
Out[894]:
In [895]:
ir= pd.interval_range(start=pd.Timestamp('2019-01-01'),
periods=3, freq='MS')
ir
Out[895]:
In [896]:
ir=pd.interval_range(start=0, end=6, periods=4)
ir
Out[896]:
In [897]:
ir=pd.interval_range(end=5, periods=4, closed='both')
ir
Out[897]:
CustomBusinessDay¶
In [898]:
from IPython.display import YouTubeVideo
YouTubeVideo('Fo0IMzfcnQE',width=900, height=500)
Out[898]:
US Holidays¶
In [899]:
df= pd.read_csv('AAPLus.csv')
df.head()
Out[899]:
In [900]:
df1= pd.date_range(start="7/1/2018", end="7/31/2018",freq='B')
df1
Out[900]:
- 2018-07-04 US National Holiday
In [901]:
from pandas.tseries.holiday import USFederalHolidayCalendar
from pandas.tseries.offsets import CustomBusinessDay
usb=CustomBusinessDay(calendar=USFederalHolidayCalendar())
usb
Out[901]:
In [902]:
df1= pd.date_range(start="7/1/2018", end="7/31/2018",freq=usb)
df1
Out[902]:
In [903]:
df.set_index(df1,inplace=True)
df
Out[903]:
Pakistan Holidays¶
In [904]:
df= pd.read_csv('AAPLpk.csv')
df
Out[904]:
In [905]:
df1= pd.date_range(start="8/1/2018", end="8/31/2018",freq='B')
df1
Out[905]:
In [906]:
'''
class USFederalHolidayCalendar(AbstractHolidayCalendar):
"""
US Federal Government Holiday Calendar based on rules specified by:
https://www.opm.gov/policy-data-oversight/
snow-dismissal-procedures/federal-holidays/
"""
rules = [
Holiday('New Years Day', month=1, day=1, observance=nearest_workday),
USMartinLutherKingJr,
USPresidentsDay,
USMemorialDay,
Holiday('July 4th', month=7, day=4, observance=nearest_workday),
USLaborDay,
USColumbusDay,
Holiday('Veterans Day', month=11, day=11, observance=nearest_workday),
USThanksgivingDay,
Holiday('Christmas', month=12, day=25, observance=nearest_workday)
]
'''
Out[906]:
In [907]:
# Pakistan Holidays Calendar Code:
# Import Required Lib:
from pandas.tseries.holiday import AbstractHolidayCalendar, nearest_workday, Holiday
class PakistanFederalHolidayCalendar(AbstractHolidayCalendar):
"""
Pakistan Federal Government Holiday Calendar based on rules specified by:
https://publicholidays.pk/2018-dates/
"""
rules = [
Holiday('Independence Day', month=8, day=14)
]
pakc=CustomBusinessDay(calendar=PakistanFederalHolidayCalendar())
pakc
Out[907]:
In [908]:
df1= pd.date_range(start="8/1/2018", end="8/31/2018",freq=pakc)
df1
Out[908]:
In [909]:
df.set_index(df1,inplace=True)
df
Out[909]:
Example¶
- Pandas Time Series Analysis:Holidays (For holidays that occur on fixed dates (e.g., US Memorial Day or July 4th) an observance rule determines when that holiday is observed if it falls on a weekend or some other non-observed day)
In [910]:
df= pd.read_csv('AAPLusaeed.csv')
df
Out[910]:
In [911]:
### Umer Saeed Birthday Calendar Code:
### Import Required Lib:
from pandas.tseries.holiday import AbstractHolidayCalendar, nearest_workday, Holiday
class UmerSaeedBirthdayCalendar(AbstractHolidayCalendar):
rules = [
Holiday('Umer Saeed Birthday', month=1, day=7,observance=nearest_workday),
]
ubc=CustomBusinessDay(calendar=UmerSaeedBirthdayCalendar())
ubc
Out[911]:
In [912]:
df1= pd.date_range(start="1/1/2018", end="1/31/2018",freq=ubc)
df1
Out[912]:
In [913]:
df.set_index(df1,inplace=True)
df
Out[913]:
In [914]:
from IPython.display import Image
Image(filename='Rules.png')
Out[914]:
Custome week end¶
In [915]:
ksa=CustomBusinessDay(weekmask='Sun Mon Tue Wed Thu')
In [916]:
df= pd.date_range(start="1/1/2018", end="1/31/2018",freq=ksa)
df
Out[916]:
In [917]:
ksa=CustomBusinessDay(weekmask='Sun Mon Tue Wed Thu',holidays=['2018-01-08'])
In [918]:
df= pd.date_range(start="1/1/2018", end="1/31/2018",freq=ksa)
df
Out[918]:
to_datetime¶
In [919]:
from IPython.display import YouTubeVideo
YouTubeVideo('igWjq3jtLYI',width=900, height=500)
Out[919]:
- Most common problem in data analysis is lack of uniformity in the structure of input data.
In [920]:
from IPython.display import Image
Image(filename='date_format.png')
Out[920]:
Example-1¶
In [921]:
df= pd.read_csv('date_data.txt')
df
Out[921]:
In [922]:
df.dtypes
Out[922]:
In [923]:
df = df.apply(pd.to_datetime)
df
Out[923]:
In [924]:
df.dtypes
Out[924]:
Example-2¶
In [925]:
df= pd.read_csv('date_data_time.txt')
df
Out[925]:
In [926]:
df.dtypes
Out[926]:
In [927]:
df = df.apply(pd.to_datetime)
df
Out[927]:
Example-3¶
In [928]:
from IPython.display import Image
Image(filename='Format_D_U_E.png')
Out[928]:
- 5th Jan in Europe, however pd.to_datetime convert to 1st May
In [929]:
pd.to_datetime('5/1/2018')
Out[929]:
Solution¶
In [930]:
pd.to_datetime('5/1/2018',dayfirst=True)
Out[930]:
In [931]:
pd.to_datetime('5$1$2018',format='%d$%m$%Y')
Out[931]:
Error Handling¶
In [932]:
df=['2019-07-01','2019-07-02','2019-07-03','2019-07-04','2019-07-05','abc']
In [933]:
pd.to_datetime(df)
Solution-1¶
In [934]:
pd.to_datetime(df,errors='ignore')
Out[934]:
Solution-2¶
In [935]:
pd.to_datetime(df,errors='coerce')
Out[935]:
Epoch unix time¶
- Epoch (unix time) is number of seconds that have passed since Jan 1, 1970 00:00:00 UTC
In [936]:
from IPython.display import Image
Image(filename='Epoch_Time.png')
Out[936]:
In [937]:
t=1570434845
# t is in seconds
# unit : string, default 'ns'
df=pd.to_datetime([t],unit='s')
df
Out[937]:
In [938]:
df.view('int64')
Out[938]:
to_timedelta¶
- Convert argument to timedelta.
- Timedeltas are absolute differences in times, expressed in difference units (e.g. days, hours, minutes, seconds).
- This method converts an argument from a recognized timedelta format / value into a Timedelta type.
- More Information
In [939]:
td = pd.Timedelta('3 days 06:05:01.000000111')
td
Out[939]:
In [940]:
td.seconds
Out[940]:
In [941]:
td = pd.Timedelta(133, unit ='s')
td
Out[941]:
In [942]:
td.seconds
Out[942]:
Period¶
Frequency as a Year¶
Method-1¶
In [943]:
a= pd.Period('2019')
a
Out[943]:
In [944]:
a.start_time
Out[944]:
In [945]:
a.end_time
Out[945]:
Method-2¶
In [946]:
a=pd.Period('2019',freq='A')
a
Out[946]:
In [947]:
a.start_time
Out[947]:
In [948]:
a.end_time
Out[948]:
Arithmetic Functions¶
Example-1¶
In [949]:
a= pd.Period('2019')
a=a+1
In [950]:
a.start_time
Out[950]:
In [951]:
a.end_time
Out[951]:
Example-2¶
In [952]:
a=pd.Period('2019',freq='A')
a=a+1
a
Out[952]:
In [953]:
a.start_time
Out[953]:
In [954]:
a.end_time
Out[954]:
Frequency as a Month¶
Method-1¶
In [955]:
m=pd.Period('2019',freq='M')
m
Out[955]:
In [956]:
m.start_time
Out[956]:
In [957]:
m.end_time
Out[957]:
Method-2¶
In [958]:
m=pd.Period('2019-10')
m
Out[958]:
In [959]:
m.start_time
Out[959]:
In [960]:
m.end_time
Out[960]:
Arithmetic Functions¶
Example-1¶
In [961]:
m=pd.Period('2019',freq='M')
m=m+1
m
Out[961]:
In [962]:
m.start_time
Out[962]:
In [963]:
m.end_time
Out[963]:
Example-2¶
In [964]:
m=pd.Period('2019-12')
m=m+1
m
Out[964]:
In [965]:
m.start_time
Out[965]:
In [966]:
m.end_time
Out[966]:
Frequency as a Day¶
Method-1¶
In [967]:
d=pd.Period('2019-10-07')
d
Out[967]:
In [968]:
d.start_time
Out[968]:
In [969]:
d.end_time
Out[969]:
Method-2¶
In [970]:
d=pd.Period('2019-10-07',freq='D')
d
Out[970]:
In [971]:
d.start_time
Out[971]:
In [972]:
d.end_time
Out[972]:
Arithmetic Functions¶
Example-1¶
In [973]:
d=pd.Period('2018-02-28')
d=d+1
d
Out[973]:
In [974]:
d.start_time
Out[974]:
In [975]:
d.end_time
Out[975]:
Example-2¶
In [976]:
d=pd.Period('2020-02-28',freq='D')
d=d+1
d
Out[976]:
In [977]:
d.start_time
Out[977]:
In [978]:
d.end_time
Out[978]:
Leap Year¶
In [979]:
pd.Period('2018-03').is_leap_year
Out[979]:
In [980]:
pd.Period('2018').is_leap_year
Out[980]:
In [981]:
pd.Period('2020-03').is_leap_year
Out[981]:
In [982]:
pd.Period('2020-10-10').is_leap_year
Out[982]:
Frequency as an Hour¶
Method-1¶
In [983]:
h=pd.Period('2020-02-28',freq='H')
h
Out[983]:
In [984]:
h.start_time
Out[984]:
In [985]:
h.end_time
Out[985]:
Method-2¶
In [986]:
h=pd.Period('2020-02-28 14:00:00',freq='H')
h
Out[986]:
In [987]:
h.start_time
Out[987]:
In [988]:
h.end_time
Out[988]:
Arithmetic Functions¶
Example-1¶
In [989]:
h=pd.Period('2020-02-28',freq='H')
h=h+1
h
Out[989]:
In [990]:
h.start_time
Out[990]:
In [991]:
h.end_time
Out[991]:
Example-2¶
In [992]:
h=pd.Period('2020-02-28 23:00:00',freq='H')
h=h+1
h
Out[992]:
In [993]:
h.start_time
Out[993]:
In [994]:
h.end_time
Out[994]:
Frequency as a Quarter¶
Method-1¶
In [995]:
q=pd.Period('2018',freq='Q')
q
Out[995]:
In [996]:
q.start_time
Out[996]:
In [997]:
q.end_time
Out[997]:
Method-2¶
In [998]:
q=pd.Period('2018-4',freq='Q')
q
Out[998]:
In [999]:
q.start_time
Out[999]:
In [1000]:
q.end_time
Out[1000]:
Method-3¶
In [1001]:
q=pd.Period('2018Q3',freq='Q')
q
Out[1001]:
In [1002]:
q.start_time
Out[1002]:
In [1003]:
q.end_time
Out[1003]:
Arithmetic Functions¶
Example-1¶
In [1004]:
q=pd.Period('2018',freq='Q')
q=q+1
q
Out[1004]:
In [1005]:
q.start_time
Out[1005]:
In [1006]:
q.end_time
Out[1006]:
Example-2¶
In [1007]:
q=pd.Period('2018-4',freq='Q')
q=q+1
q
Out[1007]:
In [1008]:
q.start_time
Out[1008]:
In [1009]:
q.end_time
Out[1009]:
Example-3¶
In [1010]:
q=pd.Period('2018Q3',freq='Q')
q=q+1
q
Out[1010]:
In [1011]:
q.start_time
Out[1011]:
In [1012]:
q.end_time
Out[1012]:
customized Quarter¶
In [1013]:
qc=pd.Period('2018', freq='Q-Jan')
qc
Out[1013]:
In [1014]:
qc.start_time
Out[1014]:
In [1015]:
qc.end_time
Out[1015]:
Arithmetic Functions¶
Example-1¶
In [1016]:
q1=pd.Period('2018', freq='Q-Jan')
In [1017]:
q1.start_time
Out[1017]:
In [1018]:
q1.end_time
Out[1018]:
In [1019]:
q2=pd.Period('2016', freq='Q-Jan')
In [1020]:
q2.start_time
Out[1020]:
In [1021]:
q2.end_time
Out[1021]:
In [1022]:
q3=q1-q2
q3
Out[1022]:
Example-2¶
In [1023]:
q1=pd.Period('2018', freq='Q-Nov')
q2=pd.Period('2016', freq='Q-Nov')
q3=q1-q2
q3
Out[1023]:
to_period¶
- More Information
- The function basically converts DatetimeIndex to PeriodIndex.
In [1024]:
df= pd.read_csv('AAPL.csv',parse_dates=["Date"],index_col="Date")
df
Out[1024]:
In [1025]:
df.to_period('Q')
Out[1025]:
offsets¶
Example-1¶
In [1026]:
df= pd.read_csv('AAPL.csv',parse_dates=['Date'])
df.head()
Out[1026]:
In [1027]:
df["NEW_DATE"] = df['Date'] - pd.offsets.DateOffset(years=1)
df.head()
Out[1027]:
Example-2¶
In [1028]:
df= pd.read_csv('AAPL.csv',parse_dates=['Date'])
df["NEW_DATE"] = df['Date'] + pd.offsets.Day(10)
df.head()
Out[1028]:
Example-3¶
In [1029]:
df= pd.read_csv('AAPL.csv',parse_dates=['Date'])
df["NEW_DATE"] = df['Date'] + pd.offsets.BDay(10)
df.head()
Out[1029]:
Example-4¶
In [1030]:
h=pd.Period('2018-12-15 20:00:00',freq='H')
h=h+pd.offsets.Hour(1)
h
Out[1030]:
In [1031]:
h.start_time
Out[1031]:
In [1032]:
h.end_time
Out[1032]:
Example-5¶
In [1033]:
h=pd.Period('2018-12-15 20:00:00',freq='H')
h=h+pd.offsets.Hour(-22)
h
Out[1033]:
In [1034]:
h.start_time
Out[1034]:
In [1035]:
h.end_time
Out[1035]:
asfreq Function¶
- Convert TimeSeries to specified frequency.
- More Information
Example-1¶
In [1036]:
q=pd.Period('2018-5',freq='Q')
In [1037]:
q.start_time
Out[1037]:
In [1038]:
q.end_time
Out[1038]:
In [1039]:
q=q.asfreq('M',how='start')
In [1040]:
q.start_time
Out[1040]:
In [1041]:
q.end_time
Out[1041]:
Example-2¶
In [1042]:
q=pd.Period('2018-5',freq='Q')
In [1043]:
q.start_time
Out[1043]:
In [1044]:
q.end_time
Out[1044]:
In [1045]:
q=q.asfreq('M',how='end')
In [1046]:
q.start_time
Out[1046]:
In [1047]:
q.end_time
Out[1047]:
PeriodIndex¶
In [1048]:
from IPython.display import YouTubeVideo
YouTubeVideo('3l9YOS4y24Y',width=900, height=500)
Out[1048]:
Example-1¶
In [1049]:
df=pd.period_range('2011','2018',freq='Q')
df
Out[1049]:
Example-2¶
In [1050]:
df=pd.period_range('2011','2018',freq='Q-Jan')
df
Out[1050]:
In [1051]:
df[0].start_time
Out[1051]:
In [1052]:
df[0].end_time
Out[1052]:
Example-3¶
In [1053]:
df= pd.read_csv('ind_data.csv')
df
Out[1053]:
In [1054]:
df.set_index('idx',inplace=True)
In [1055]:
df
Out[1055]:
In [1056]:
df.index
Out[1056]:
In [1057]:
df.index= pd.PeriodIndex(df.index,freq='Q')
In [1058]:
df.index
Out[1058]:
In [1059]:
df['2012']
Out[1059]:
In [1060]:
df['2011':'2012']
Out[1060]:
Example-4¶
In [1061]:
df= pd.read_csv('ts_ds.csv')
df
Out[1061]:
Required Oputput¶
In [1062]:
from IPython.display import Image
Image(filename='Required_Output.png')
Out[1062]:
In [1063]:
df.set_index('LineItem', inplace = True)
In [1064]:
df
Out[1064]:
In [1065]:
df=df.T
df
Out[1065]:
In [1066]:
df.index
Out[1066]:
In [1067]:
df.index= pd.PeriodIndex(df.index,freq='Q-Jan')
In [1068]:
df['Start Date']=df.index.map(lambda x: x.start_time)
df['End Date']=df.index.map(lambda x: x.end_time.floor("H"))
df
Out[1068]:
In [1069]:
# Day Name
df['DayName']=df['Start Date'].dt.weekday_name
# Get day of the month that a Period falls on
df['dayc']=df['Start Date'].dt.day
# Get Month Name
df['month']=df['Start Date'].dt.month
# Return the day of the year.
df['daynumber']=df['Start Date'].dt.dayofyear
# Get quarter Number
df['quarterernumb']=df['Start Date'].dt.quarter
# Day of the week the period lies in, with Monday=0 and Sunday=6.
df['dow']=df['Start Date'].dt.dayofweek
# Get the total number of days in the month that this period falls on.
df['dim']=df['Start Date'].dt.days_in_month
# year
df['yeartest']=df['Start Date'].dt.year
# Get the week of the year on the given Period.
df['weekn']=df['Start Date'].dt.week
df
Out[1069]:
TimeZone¶
In [1070]:
from IPython.display import Image
Image(filename='TimeZone.png')
Out[1070]:
- Two Types of DateTime objects in Python:
- 1) Naive (No timezone awareness)
- 2) Time Zone aware datetime
In [1071]:
from IPython.display import YouTubeVideo
YouTubeVideo('9IW2GIJajLs',width=900, height=500)
Out[1071]:
In [1072]:
from pytz import all_timezones
In [1073]:
all_timezones
Out[1073]:
Example-1¶
In [1074]:
df=pd.read_csv('TZH.csv',parse_dates=['Date Time'])
df
Out[1074]:
In [1075]:
df.set_index('Date Time', inplace = True)
In [1076]:
df
Out[1076]:
In [1077]:
df.index
Out[1077]:
In [1078]:
df=df.tz_localize(tz='Asia/Istanbul')
In [1079]:
df
Out[1079]:
In [1080]:
df.index
Out[1080]:
- Convert tz-aware axis to target time zone.
- More Information
Example-2¶
In [1081]:
df=df.tz_convert(tz='Asia/Karachi')
df
Out[1081]:
In [1082]:
df.index
Out[1082]:
In [1083]:
df=df.tz_convert(tz='dateutil/Europe/Berlin')
df
Out[1083]:
Arithmetic Functions¶
Data Frame-1¶
In [1084]:
pakistan= pd.read_csv('Karachi.csv',parse_dates=['Date'])
pakistan.head()
Out[1084]:
In [1085]:
pakistan.set_index('Date', inplace = True)
In [1086]:
pakistan.head()
Out[1086]:
In [1087]:
pakistan.index
Out[1087]:
- Localize tz-naive TimeSeries to target time zone.
- More Information
In [1088]:
pakistan=pakistan.tz_localize(tz='Asia/Karachi')
pakistan
Out[1088]:
In [1089]:
pakistan.index
Out[1089]:
Data Frame-2¶
In [1090]:
turki= pd.read_csv('Istanbul.csv',parse_dates=['Date'])
turki.head()
Out[1090]:
In [1091]:
turki.set_index('Date', inplace = True)
In [1092]:
turki.head()
Out[1092]:
In [1093]:
turki.index
Out[1093]:
In [1094]:
turki=turki.tz_localize(tz='Asia/Istanbul')
In [1095]:
turki.index
Out[1095]:
In [1096]:
turki
Out[1096]:
In [1097]:
f_res=pakistan+turki
f_res
Out[1097]:
tshift¶
- Shift the time index, using the index’s frequency if available.
- More Information
In [1098]:
df= pd.read_csv('egg_price.csv',parse_dates=['Date'],index_col='Date')
df
Out[1098]:
In [1099]:
df.tshift(1)
Out[1099]:
In [1100]:
df.tshift(-1)
Out[1100]:
first¶
- first: Convenience method for subsetting initial periods of time series data based on a date offset.
- More Information
In [1101]:
i = pd.date_range('2018-04-09', periods=4, freq='2D')
ts = pd.DataFrame({'A': [1,2,3,4]}, index=i)
ts
Out[1101]:
- Get the rows for the first 3 days:
In [1102]:
ts.first('3D')
Out[1102]:
Notice the data for 3 first calender days were returned, not the first 3 days observed in the dataset, and therefore data for 2018-04-13 was not returned.
last¶
- last: Convenience method for subsetting final periods of time series data based on a date offset.
- More Information
In [1103]:
i = pd.date_range('2018-04-09', periods=4, freq='2D')
ts = pd.DataFrame({'A': [1,2,3,4]}, index=i)
ts
Out[1103]:
In [1104]:
ts.last('3D')
Out[1104]:
- Notice the data for 3 last calender days were returned, not the last 3 observed days in the dataset, and therefore data for 2018-04-11 was not returned.
between_time¶
Example-1¶
In [1105]:
df= pd.read_csv('Cell_H_O.csv',index_col="Time",parse_dates=["Time"])
df.head()
Out[1105]:
In [1106]:
df.between_time('6:00','8:00')
Out[1106]:
Example-2¶
In [1107]:
df= pd.read_csv('Cell_H.csv',index_col="Time",parse_dates=["Time"])
df.head()
Out[1107]:
In [1108]:
df.between_time('6:00','8:00')
Out[1108]:
at_time¶
Example-1¶
In [1109]:
df= pd.read_csv('Cell_H_O.csv',index_col="Time",parse_dates=["Time"])
df.head()
Out[1109]:
In [1110]:
df.at_time('6:00')
Out[1110]:
Example-2¶
In [1111]:
df= pd.read_csv('Cell_H.csv',index_col="Time",parse_dates=["Time"])
df.head()
Out[1111]:
In [1112]:
df.at_time('6:00')
Out[1112]:
More of your pandas questions answered¶
In [1113]:
from IPython.display import YouTubeVideo
YouTubeVideo('oH3wYKvwpJ8',width=900, height=500)
Out[1113]:
MultiIndex in pandas¶
In [1114]:
from IPython.display import YouTubeVideo
YouTubeVideo('tcRGa2soc-c',width=900, height=500)
Out[1114]:
new time-saving tricks in pandas¶
In [1115]:
from IPython.display import YouTubeVideo
YouTubeVideo('-NbY7E9hKxk',width=900, height=500)
Out[1115]:
In [1116]:
from IPython.display import YouTubeVideo
YouTubeVideo('te5JrSCW-LY',width=900, height=500)
Out[1116]:
In [1117]:
from IPython.display import YouTubeVideo
YouTubeVideo('CWRKgBtZN18',width=900, height=500)
Out[1117]:
In [1118]:
from IPython.display import YouTubeVideo
YouTubeVideo('RlIiVeig3hc',width=900, height=500)
Out[1118]:
Shifting and Lagging¶
In [1119]:
from IPython.display import YouTubeVideo
YouTubeVideo('0lsmdNLNorY',width=900, height=500)
Out[1119]:
get¶
- More Information
- Extract element from each component at specified position.
- Extract element from lists, tuples, or strings in each element in the Series/Index.
In [1120]:
df_who= pd.read_csv('WHO_csv.csv',dtype = {"Region" : "category"})
df_who.head()
Out[1120]:
In [1121]:
df_who['Country0']=df_who['Country'].str.get(0)
df_who.head()
Out[1121]: